@cornerstonejs/tools 1.52.0 → 1.54.0

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,86 @@ 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).
+ * @param annotation - Annotation
+ */
+function clearParentAnnotation(annotation: Annotation): void {
+  const { annotationUID: childUID, parentAnnotationUID } = annotation;
+
+  if (!parentAnnotationUID) {
+    return;
+  }
+
+  const parentAnnotation = getAnnotation(parentAnnotationUID);
+  const childUIDIndex = parentAnnotation.childAnnotationUIDs.indexOf(childUID);
+
+  parentAnnotation.childAnnotationUIDs.splice(childUIDIndex, 1);
+  annotation.parentAnnotationUID = undefined;
+}
+
+/**
+ * Creates a parent/child association between annotations.
+ * A annotation may have only one parent and multiple children (eg: a contour
+ * may have multiple holes in it).
+ * @param parentAnnotation - Parent annotation
+ * @param childAnnotation - Child annotation
+ */
+function addChildAnnotation(
+  parentAnnotation: Annotation,
+  childAnnotation: Annotation
+): void {
+  const { annotationUID: parentUID } = parentAnnotation;
+  const { annotationUID: childUID } = childAnnotation;
+
+  // Make sure it is not associated with any other tool
+  clearParentAnnotation(childAnnotation);
+
+  if (!parentAnnotation.childAnnotationUIDs) {
+    parentAnnotation.childAnnotationUIDs = [];
+  }
+
+  // Check if it is already a child
+  if (parentAnnotation.childAnnotationUIDs.includes(childUID)) {
+    return;
+  }
+
+  parentAnnotation.childAnnotationUIDs.push(childUID);
+  childAnnotation.parentAnnotationUID = parentUID;
+}
+
+/**
+ * Returns the parent annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Parent annotation
+ */
+function getParentAnnotation(annotation: Annotation) {
+  return annotation.parentAnnotationUID
+    ? getAnnotation(annotation.parentAnnotationUID)
+    : undefined;
+}
+
+/**
+ * Returns all children annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Child annotations
+ */
+function getChildAnnotations(annotation: Annotation) {
+  return (
+    annotation.childAnnotationUIDs?.map((childAnnotationUID) =>
+      getAnnotation(childAnnotationUID)
+    ) ?? []
+  );
+}
+
 /**
  * Add the annotation to the annotation manager along with the options that is
  * used to filter the annotation manager and the annotation group that
@@ -137,6 +217,11 @@ function removeAnnotation(annotationUID: string): void {
     return;
   }
 
+  // Remove all child annotations first
+  annotation.childAnnotationUIDs?.forEach((childAnnotationUID) =>
+    removeAnnotation(childAnnotationUID)
+  );
+
   manager.removeAnnotation(annotationUID);
 
   // trigger annotation removed
@@ -169,8 +254,29 @@ function removeAllAnnotations(): void {
   manager.removeAllAnnotations();
 }
 
+/**
+ * Invalidate current and all parent annotations (eg: contour holes)
+ * @param annotation - Annotation
+ */
+function invalidateAnnotation(annotation: Annotation): void {
+  let currAnnotation = annotation;
+
+  while (currAnnotation) {
+    currAnnotation.invalidated = true;
+
+    currAnnotation = currAnnotation.parentAnnotationUID
+      ? getAnnotation(currAnnotation.parentAnnotationUID)
+      : undefined;
+  }
+}
+
 export {
+  getAllAnnotations,
   getAnnotations,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   getNumberOfAnnotations,
   addAnnotation,
   getAnnotation,
@@ -180,4 +286,5 @@ export {
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
 };

package/src/stateManagement/annotation/helpers/state.ts

@@ -11,6 +11,7 @@ import {
   AnnotationAddedEventDetail,
   AnnotationModifiedEventDetail,
   AnnotationCompletedEventDetail,
+  ContourAnnotationCompletedEventDetail,
 } from '../../../types/EventTypes';
 
 /**
@@ -105,11 +106,37 @@ function triggerAnnotationModified(
  * Triggers an annotation completed event.
  */
 function triggerAnnotationCompleted(annotation: Annotation): void {
-  const eventType = Events.ANNOTATION_COMPLETED;
   const eventDetail: AnnotationCompletedEventDetail = {
     annotation,
   };
 
+  _triggerAnnotationCompleted(eventDetail);
+}
+
+/**
+ * Triggers an annotation completed event for contours (same annotation completed
+ * event but with more specific details).
+ */
+function triggerContourAnnotationCompleted(
+  annotation: Annotation,
+  contourHoleProcessingEnabled = false
+): void {
+  const eventDetail: ContourAnnotationCompletedEventDetail = {
+    annotation,
+    contourHoleProcessingEnabled,
+  };
+
+  _triggerAnnotationCompleted(eventDetail);
+}
+
+/**
+ * Triggers an annotation completed event for the `detail` provided
+ * @param eventDetail - Event detail
+ */
+function _triggerAnnotationCompleted(
+  eventDetail: AnnotationCompletedEventDetail
+) {
+  const eventType = Events.ANNOTATION_COMPLETED;
   triggerEvent(eventTarget, eventType, eventDetail);
 }
 
@@ -118,4 +145,5 @@ export {
   triggerAnnotationAddedForFOR,
   triggerAnnotationModified,
   triggerAnnotationCompleted,
+  triggerContourAnnotationCompleted,
 };

package/src/stateManagement/index.js

@@ -9,10 +9,15 @@ import {
   addAnnotation,
   removeAnnotation,
   getAnnotation,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   getNumberOfAnnotations,
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
 } from './annotation/annotationState';
 
 import {
@@ -31,9 +36,14 @@ export {
   getNumberOfAnnotations,
   removeAnnotation,
   getAnnotation,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
   // segmentations
   addSegmentationRepresentations,
   removeSegmentationsFromToolGroup,

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 };