@cornerstonejs/tools 1.50.3 → 1.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.50.3",
+  "version": "1.51.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.50.3",
+    "@cornerstonejs/core": "^1.51.0",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "20a87794b2cb1933c1d09e07ce9bd6a69610a7a1"
+  "gitHead": "a4ca4dde651d17e658a4aec5a4e3ec1b274dc580"
 }

package/src/eventListeners/annotations/annotationCompletedListener.ts

@@ -0,0 +1,13 @@
+import { AnnotationCompletedEventType } from '../../types/EventTypes';
+import * as contourSegUtils from '../../utilities/contourSegmentation';
+import { contourSegmentationCompleted } from './contourSegmentation';
+
+export default function annotationCompletedListener(
+  evt: AnnotationCompletedEventType
+) {
+  const annotation = evt.detail.annotation;
+
+  if (contourSegUtils.isContourSegmentationAnnotation(annotation)) {
+    contourSegmentationCompleted(evt);
+  }
+}

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

@@ -0,0 +1,273 @@
+import {
+  getEnabledElement,
+  utilities as csUtils,
+  Types,
+} from '@cornerstonejs/core';
+import { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
+import {
+  getViewportForAnnotation,
+  math,
+  triggerAnnotationRenderForViewportIds,
+} from '../../../utilities';
+import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
+import {
+  getAnnotations,
+  addAnnotation,
+  removeAnnotation,
+} from '../../../stateManagement/annotation/annotationState';
+import { AnnotationCompletedEventType } from '../../../types/EventTypes';
+import * as contourUtils from '../../../utilities/contours';
+import * as contourSegUtils from '../../../utilities/contourSegmentation';
+import { ToolGroupManager, hasTool as cstHasTool } from '../../../store';
+import { PlanarFreehandContourSegmentationTool } from '../../../tools';
+
+const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+
+export default function contourSegmentationCompletedListener(
+  evt: AnnotationCompletedEventType
+) {
+  const sourceAnnotation = evt.detail
+    .annotation as ContourSegmentationAnnotation;
+
+  if (!contourSegUtils.isContourSegmentationAnnotation(sourceAnnotation)) {
+    return;
+  }
+
+  const viewport = getViewportForAnnotation(sourceAnnotation);
+  const contourSegmentationAnnotations =
+    getValidContourSegmentationAnnotations(sourceAnnotation);
+
+  if (!contourSegmentationAnnotations.length) {
+    return;
+  }
+
+  const sourcePolyline = convertContourPolylineToCanvasSpace(
+    sourceAnnotation.data.contour.polyline,
+    viewport
+  );
+
+  const targetAnnotationInfo = findIntersectingContour(
+    viewport,
+    sourcePolyline,
+    contourSegmentationAnnotations
+  );
+
+  if (!targetAnnotationInfo) {
+    return;
+  }
+
+  if (!isFreehandContourSegToolRegistered(viewport)) {
+    return;
+  }
+
+  const { targetAnnotation, targetPolyline } = targetAnnotationInfo;
+
+  processContours(
+    viewport,
+    sourceAnnotation,
+    sourcePolyline,
+    targetAnnotation,
+    targetPolyline
+  );
+}
+
+function isFreehandContourSegToolRegistered(viewport: Types.IViewport) {
+  const { toolName } = PlanarFreehandContourSegmentationTool;
+
+  if (!cstHasTool(PlanarFreehandContourSegmentationTool)) {
+    console.warn(`${toolName} is not registered in cornerstone`);
+    return false;
+  }
+
+  const toolGroup = ToolGroupManager.getToolGroupForViewport(
+    viewport.id,
+    viewport.renderingEngineId
+  );
+
+  if (!toolGroup.hasTool(toolName)) {
+    console.warn(`Tool ${toolName} not added to ${toolGroup.id} toolGroup`);
+    return false;
+  }
+
+  if (!toolGroup.getToolOptions(toolName)) {
+    console.warn(`Tool ${toolName} must be in active/passive state`);
+    return false;
+  }
+
+  return true;
+}
+
+function convertContourPolylineToCanvasSpace(
+  polyline: Types.Point3[],
+  viewport: Types.IViewport
+): Types.Point2[] {
+  const numPoints = polyline.length;
+  const projectedPolyline = new Array(numPoints);
+
+  for (let i = 0; i < numPoints; i++) {
+    projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+  }
+
+  return projectedPolyline;
+}
+
+function convertPolylineToWorldSpace(
+  polyline: Types.Point2[],
+  viewport: Types.IViewport
+): Types.Point3[] {
+  const numPoints = polyline.length;
+  const projectedPolyline = new Array(numPoints);
+
+  for (let i = 0; i < numPoints; i++) {
+    projectedPolyline[i] = viewport.canvasToWorld(polyline[i]);
+  }
+
+  return projectedPolyline;
+}
+
+function getValidContourSegmentationAnnotations(
+  sourceAnnotation: ContourSegmentationAnnotation
+): ContourSegmentationAnnotation[] {
+  const { annotationUID: sourceAnnotationUID } = sourceAnnotation;
+  const { FrameOfReferenceUID } = sourceAnnotation.metadata;
+
+  // 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);
+  }, []);
+}
+
+function findIntersectingContour(
+  viewport: Types.IViewport,
+  sourcePolyline: Types.Point2[],
+  contourSegmentationAnnotations: ContourSegmentationAnnotation[]
+): {
+  targetAnnotation: ContourSegmentationAnnotation;
+  targetPolyline: Types.Point2[];
+} {
+  const sourceAABB = math.polyline.getAABB(sourcePolyline);
+
+  for (let i = 0; i < contourSegmentationAnnotations.length; i++) {
+    const targetAnnotation = contourSegmentationAnnotations[i];
+    const targetPolyline = convertContourPolylineToCanvasSpace(
+      targetAnnotation.data.contour.polyline,
+      viewport
+    );
+
+    const targetAABB = math.polyline.getAABB(targetPolyline);
+    const polylinesIntersect =
+      math.aabb.intersectAABB(sourceAABB, targetAABB) &&
+      math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
+
+    if (polylinesIntersect) {
+      return { targetAnnotation, targetPolyline };
+    }
+  }
+}
+
+function processContours(
+  viewport: Types.IViewport,
+  sourceAnnotation: ContourSegmentationAnnotation,
+  sourcePolyline: Types.Point2[],
+  targetAnnotation: ContourSegmentationAnnotation,
+  targetPolyline: Types.Point2[]
+) {
+  const sourceStartPoint = sourcePolyline[0];
+  const mergePolylines = math.polyline.containsPoint(
+    targetPolyline,
+    sourceStartPoint
+  );
+
+  const newPolylines = [];
+
+  if (mergePolylines) {
+    const mergedPolyline = math.polyline.mergePolylines(
+      targetPolyline,
+      sourcePolyline
+    );
+
+    newPolylines.push(mergedPolyline);
+  } else {
+    const subtractedPolylines = math.polyline.subtractPolylines(
+      targetPolyline,
+      sourcePolyline
+    );
+
+    subtractedPolylines.forEach((newPolyline) =>
+      newPolylines.push(newPolyline)
+    );
+  }
+
+  removeAnnotation(sourceAnnotation.annotationUID);
+  removeAnnotation(targetAnnotation.annotationUID);
+
+  const { element } = viewport;
+  const enabledElement = getEnabledElement(element);
+  const { renderingEngine } = enabledElement;
+  const { metadata, data } = targetAnnotation;
+  const { handles, segmentation } = data;
+  const { textBox } = handles;
+
+  for (let i = 0; i < newPolylines.length; i++) {
+    const polyline = convertPolylineToWorldSpace(newPolylines[i], viewport);
+    const startPoint = polyline[0];
+    const endPoint = polyline[polyline.length - 1];
+    const newAnnotation = {
+      metadata: {
+        ...metadata,
+        toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
+      },
+      data: {
+        cachedStats: {},
+        handles: {
+          points: [startPoint, endPoint],
+          textBox: textBox ? { ...textBox } : undefined,
+        },
+        contour: {
+          polyline,
+          closed: true,
+        },
+        segmentation: {
+          ...segmentation,
+        },
+      },
+      annotationUID: csUtils.uuidv4() as string,
+      highlighted: true,
+      invalidated: true,
+      isLocked: false,
+      isVisible: undefined,
+    };
+
+    addAnnotation(newAnnotation, element);
+
+    // Updating a Spline contours, for example, should also update freehand contours
+    const updatedTtoolNames = new Set([
+      DEFAULT_CONTOUR_SEG_TOOLNAME,
+      targetAnnotation.metadata.toolName,
+    ]);
+
+    for (const toolName of updatedTtoolNames.values()) {
+      const viewportIdsToRender = getViewportIdsWithToolToRender(
+        element,
+        toolName
+      );
+      triggerAnnotationRenderForViewportIds(
+        renderingEngine,
+        viewportIdsToRender
+      );
+    }
+  }
+}

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

@@ -0,0 +1 @@
+export { default as contourSegmentationCompleted } from './contourSegmentationCompleted';

package/src/eventListeners/annotations/index.ts

@@ -1,4 +1,9 @@
+import annotationCompletedListener from './annotationCompletedListener';
 import annotationSelectionListener from './annotationSelectionListener';
 import annotationModifiedListener from './annotationModifiedListener';
 
-export { annotationSelectionListener, annotationModifiedListener };
+export {
+  annotationCompletedListener,
+  annotationSelectionListener,
+  annotationModifiedListener,
+};

package/src/eventListeners/index.ts

@@ -10,6 +10,7 @@ import {
   imageChangeEventListener,
 } from './segmentation';
 import {
+  annotationCompletedListener,
   annotationSelectionListener,
   annotationModifiedListener,
 } from './annotations';
@@ -25,6 +26,7 @@ export {
   segmentationRepresentationRemovedEventListener,
   segmentationDataModifiedEventListener,
   imageChangeEventListener,
+  annotationCompletedListener,
   annotationSelectionListener,
   annotationModifiedListener,
 };

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

@@ -0,0 +1,117 @@
+import {
+  cache,
+  getEnabledElementByIds,
+  utilities as csUtils,
+} 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
+ *  often is as a result of tool interactions e.g., scissors, eraser, etc.
+ */
+const onLabelmapSegmentationDataModified = function (
+  evt: SegmentationDataModifiedEventType
+): void {
+  const { segmentationId, modifiedSlicesToUse } = evt.detail;
+
+  const { representationData, type } =
+    SegmentationState.getSegmentation(segmentationId);
+
+  const toolGroupIds =
+    SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
+
+  if (type !== SegmentationRepresentations.Labelmap) {
+    throw new Error(
+      `onLabelmapSegmentationDataModifiedListener: representationType ${type} not supported yet`
+    );
+  }
+
+  if (isVolumeSegmentation(representationData[type])) {
+    // 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);
+    });
+
+    // Trigger modified on the imageData to update the image
+    imageData.modified();
+  } else {
+    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;
+
+          const actorEntry = viewport.getActor(
+            representation.segmentationRepresentationUID
+          );
+
+          if (!actorEntry) {
+            return;
+          }
+
+          const currentImageId = viewport.getCurrentImageId();
+
+          const segImageData = actorEntry.actor.getMapper().getInputData();
+
+          const { imageIdReferenceMap } = representationData[
+            type
+          ] as LabelmapSegmentationDataStack;
+
+          const currentSegmentationImageId =
+            imageIdReferenceMap.get(currentImageId);
+
+          const segmentationImage = cache.getImage(currentSegmentationImageId);
+          segImageData.modified();
+
+          // update the cache with the new image data
+          csUtils.updateVTKImageDataWithCornerstoneImage(
+            segImageData,
+            segmentationImage
+          );
+        });
+      });
+    });
+  }
+};
+
+export default onLabelmapSegmentationDataModified;

package/src/eventListeners/segmentation/segmentationDataModifiedEventListener.ts

@@ -1,19 +1,8 @@
-import {
-  cache,
-  getEnabledElementByIds,
-  utilities as csUtils,
-} from '@cornerstonejs/core';
-
 import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
 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';
+import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
 
 /** A callback function that is called when the segmentation data is modified which
  *  often is as a result of tool interactions e.g., scissors, eraser, etc.
@@ -21,97 +10,14 @@ import { getToolGroup } from '../../store/ToolGroupManager';
 const onSegmentationDataModified = function (
   evt: SegmentationDataModifiedEventType
 ): void {
-  const { segmentationId, modifiedSlicesToUse } = evt.detail;
-
-  const { representationData, type } =
-    SegmentationState.getSegmentation(segmentationId);
+  const { segmentationId } = evt.detail;
+  const { type } = SegmentationState.getSegmentation(segmentationId);
 
   const toolGroupIds =
     SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
 
-  if (type !== SegmentationRepresentations.Labelmap) {
-    throw new Error(
-      `onSegmentationDataModified: representationType ${type} not supported yet`
-    );
-  }
-
-  if (isVolumeSegmentation(representationData[type])) {
-    // 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);
-    });
-
-    // Trigger modified on the imageData to update the image
-    imageData.modified();
-  } else {
-    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;
-
-          const actorEntry = viewport.getActor(
-            representation.segmentationRepresentationUID
-          );
-
-          if (!actorEntry) {
-            return;
-          }
-
-          const currentImageId = viewport.getCurrentImageId();
-
-          const segImageData = actorEntry.actor.getMapper().getInputData();
-
-          const { imageIdReferenceMap } = representationData[
-            type
-          ] as LabelmapSegmentationDataStack;
-
-          const currentSegmentationImageId =
-            imageIdReferenceMap.get(currentImageId);
-
-          const segmentationImage = cache.getImage(currentSegmentationImageId);
-          segImageData.modified();
-
-          // update the cache with the new image data
-          csUtils.updateVTKImageDataWithCornerstoneImage(
-            segImageData,
-            segmentationImage
-          );
-        });
-      });
-    });
+  if (type === SegmentationRepresentations.Labelmap) {
+    onLabelmapSegmentationDataModified(evt);
   }
 
   toolGroupIds.forEach((toolGroupId) => {

package/src/init.ts

@@ -5,12 +5,13 @@ import { Events as TOOLS_EVENTS } from './enums';
 import { addEnabledElement, removeEnabledElement } from './store';
 import { resetCornerstoneToolsState } from './store/state';
 import {
+  annotationCompletedListener,
   annotationSelectionListener,
+  annotationModifiedListener,
   segmentationDataModifiedEventListener,
   segmentationRepresentationModifiedEventListener,
   segmentationRepresentationRemovedEventListener,
   segmentationModifiedListener,
-  annotationModifiedListener,
 } from './eventListeners';
 import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 
@@ -103,6 +104,11 @@ function _addCornerstoneToolsEventListeners() {
   /**
    * Annotation
    */
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_COMPLETED,
+    annotationCompletedListener
+  );
+
   eventTarget.addEventListener(
     TOOLS_EVENTS.ANNOTATION_MODIFIED,
     annotationModifiedListener
@@ -148,6 +154,11 @@ function _removeCornerstoneToolsEventListeners() {
   /**
    * Annotation
    */
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.ANNOTATION_COMPLETED,
+    annotationCompletedListener
+  );
+
   eventTarget.removeEventListener(
     TOOLS_EVENTS.ANNOTATION_MODIFIED,
     annotationModifiedListener

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

@@ -7,7 +7,11 @@ import {
 import { Events } from '../../../enums';
 import { Annotation } from '../../../types/AnnotationTypes';
 import { getToolGroupsWithToolName } from '../../../store/ToolGroupManager';
-import { AnnotationAddedEventDetail } from '../../../types/EventTypes';
+import {
+  AnnotationAddedEventDetail,
+  AnnotationModifiedEventDetail,
+  AnnotationCompletedEventDetail,
+} from '../../../types/EventTypes';
 
 /**
  * It triggers an event for the element when an annotation is added
@@ -76,4 +80,40 @@ function triggerAnnotationAddedForFOR(annotation: Annotation) {
   });
 }
 
-export { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR };
+/**
+ * Triggers an annotation modified event.
+ */
+function triggerAnnotationModified(
+  annotation: Annotation,
+  element: HTMLDivElement
+): void {
+  const enabledElement = getEnabledElement(element);
+  const { viewportId, renderingEngineId } = enabledElement;
+  const eventType = Events.ANNOTATION_MODIFIED;
+  const eventDetail: AnnotationModifiedEventDetail = {
+    annotation,
+    viewportId,
+    renderingEngineId,
+  };
+
+  triggerEvent(eventTarget, eventType, eventDetail);
+}
+
+/**
+ * Triggers an annotation completed event.
+ */
+function triggerAnnotationCompleted(annotation: Annotation): void {
+  const eventType = Events.ANNOTATION_COMPLETED;
+  const eventDetail: AnnotationCompletedEventDetail = {
+    annotation,
+  };
+
+  triggerEvent(eventTarget, eventType, eventDetail);
+}
+
+export {
+  triggerAnnotationAddedForElement,
+  triggerAnnotationAddedForFOR,
+  triggerAnnotationModified,
+  triggerAnnotationCompleted,
+};

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -87,6 +87,16 @@ export default class ToolGroup implements IToolGroup {
 
     return toolInstance;
   }
+
+  /**
+   * Check if a tool is already added to the tool group
+   * @param toolName - Tool name
+   * @returns True if the tool is already added or false otherwise
+   */
+  hasTool(toolName: string): boolean {
+    return !!this._toolInstances[toolName];
+  }
+
   /**
    * Add a tool to the tool group with the given tool name and tool configuration.
    * Note that adding a tool to a tool group will not automatically set the tool