@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.8

package/src/eventListeners/segmentation/imageChangeEventListener.ts

@@ -0,0 +1,272 @@
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import {
+  BaseVolumeViewport,
+  getEnabledElement,
+  Enums,
+  getEnabledElementByIds,
+  cache,
+  utilities,
+  Types,
+} from '@cornerstonejs/core';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+import Representations from '../../enums/SegmentationRepresentations';
+import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
+import { LabelmapSegmentationDataStack } from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
+
+const enable = function (element: HTMLDivElement): void {
+  const { viewport } = getEnabledElement(element);
+
+  if (viewport instanceof BaseVolumeViewport) {
+    return;
+  }
+
+  element.addEventListener(
+    Enums.Events.STACK_NEW_IMAGE,
+    _imageChangeEventListener as EventListener
+  );
+  // this listener handles the segmentation modifications
+  element.addEventListener(
+    Enums.Events.IMAGE_RENDERED,
+    _imageChangeEventListener as EventListener
+  );
+};
+
+const disable = function (element: HTMLDivElement): void {
+  element.removeEventListener(
+    Enums.Events.STACK_NEW_IMAGE,
+    _imageChangeEventListener as EventListener
+  );
+  element.removeEventListener(
+    Enums.Events.IMAGE_RENDERED,
+    _imageChangeEventListener as EventListener
+  );
+};
+
+const perToolGroupManualTriggers = new Map();
+
+/**
+ *  When the image is rendered, check what tools can be rendered for this element.
+ *
+ * - First we get all tools which are active, passive or enabled on the element.
+ * - If any of these tools have a `renderAnnotation` method, then we render them.
+ * - Note that these tools don't necessarily have to be instances of  `AnnotationTool`,
+ *   Any tool may register a `renderAnnotation` method (e.g. a tool that displays an overlay).
+ *
+ * @param evt - The normalized IMAGE_RENDERED event.
+ */
+function _imageChangeEventListener(evt) {
+  const eventData = evt.detail;
+  const { viewportId, renderingEngineId } = eventData;
+  const { viewport } = getEnabledElementByIds(
+    viewportId,
+    renderingEngineId
+  ) as { viewport: Types.IStackViewport };
+
+  const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+
+  if (!toolGroup) {
+    return;
+  }
+
+  let toolGroupSegmentationRepresentations =
+    SegmentationState.getSegmentationRepresentations(toolGroup.id) || [];
+
+  toolGroupSegmentationRepresentations =
+    toolGroupSegmentationRepresentations.filter(
+      (representation) => representation.type === Representations.Labelmap
+    );
+
+  if (!toolGroupSegmentationRepresentations?.length) {
+    return;
+  }
+
+  const segmentationRepresentations = {};
+  toolGroupSegmentationRepresentations.forEach((representation) => {
+    const segmentation = SegmentationState.getSegmentation(
+      representation.segmentationId
+    );
+
+    if (!segmentation || !segmentation.representationData?.LABELMAP) {
+      return;
+    }
+
+    const labelmapData = segmentation.representationData.LABELMAP;
+
+    if (isVolumeSegmentation(labelmapData, viewport)) {
+      return;
+    }
+
+    const { imageIdReferenceMap } =
+      labelmapData as LabelmapSegmentationDataStack;
+
+    segmentationRepresentations[representation.segmentationRepresentationUID] =
+      {
+        imageIdReferenceMap,
+      };
+  });
+
+  const representationList = Object.keys(segmentationRepresentations);
+  const currentImageId = viewport.getCurrentImageId();
+  const actors = viewport.getActors();
+
+  const segmentationFound = actors.find((actor) => {
+    if (!representationList.includes(actor.uid)) {
+      return false;
+    }
+
+    return true;
+  });
+
+  if (!segmentationFound) {
+    // If the segmentation is not found, it could be because of some special cases
+    // where we are in the process of updating the volume conversion to a stack while
+    // the data is still coming in. In such situations, we should trigger the render
+    // to ensure that the segmentation actors are created, even if the data arrives late.
+
+    if (!perToolGroupManualTriggers.has(toolGroup.id)) {
+      perToolGroupManualTriggers.set(toolGroup.id, true);
+      triggerSegmentationRender(toolGroup.id);
+    }
+
+    // we should return here, since there is no segmentation actor to update
+    // we will hit this function later on after the actor is created
+    return;
+  }
+
+  actors.forEach((actor) => {
+    if (!representationList.includes(actor.uid)) {
+      return;
+    }
+    const segmentationActor = actor.actor;
+
+    const { imageIdReferenceMap } = segmentationRepresentations[actor.uid];
+
+    const derivedImageId = imageIdReferenceMap.get(currentImageId);
+
+    const segmentationImageData = segmentationActor.getMapper().getInputData();
+
+    if (!derivedImageId) {
+      // this means that this slice doesn't have a segmentation for this representation
+      // this can be a case where the segmentation was added to certain slices only
+      // so we can keep the actor but empty out the imageData
+      if (segmentationImageData.setDerivedImage) {
+        // If the image data has a set derived image, then it should be called
+        // to update any vtk or actor data associated with it.  In this case, null
+        // is used to clear the data.  THis allows intercepting/alternative
+        // to vtk calls.  Eventually the vtk version should also use this.
+        segmentationImageData.setDerivedImage(null);
+        return;
+      }
+      // This is the vtk version of the clearing out the image data, and fails
+      // to work for non scalar image data.
+      const scalarArray = vtkDataArray.newInstance({
+        name: 'Pixels',
+        numberOfComponents: 1,
+        values: new Uint8Array(segmentationImageData.getNumberOfPoints()),
+      });
+
+      const imageData = vtkImageData.newInstance();
+      imageData.getPointData().setScalars(scalarArray);
+      segmentationActor.getMapper().setInputData(imageData);
+      return;
+    }
+
+    const derivedImage = cache.getImage(derivedImageId);
+
+    const { dimensions, spacing, direction } =
+      viewport.getImageDataMetadata(derivedImage);
+
+    const currentImage =
+      cache.getImage(currentImageId) ||
+      ({
+        imageId: currentImageId,
+      } as Types.IImage);
+    const { origin: currentOrigin } =
+      viewport.getImageDataMetadata(currentImage);
+
+    // IMPORTANT: We need to make sure that the origin of the segmentation
+    // is the same as the current image origin. This is because due to some
+    // floating point precision issues, when coming from volume to stack
+    // the origin of the segmentation can be slightly different from the
+    // current image origin. This can cause the segmentation to be rendered
+    // in the wrong location.
+    // Todo: This will not work for segmentations that are not in the same frame
+    // of reference or derived from the same image. This can happen when we have
+    // a segmentation that happens to exist in the same space as the image but is
+    // not derived from it. We need to find a way to handle this case, but don't think
+    // it makes sense to do it for the stack viewport, as the volume viewport is designed to handle this case.
+    const originToUse = currentOrigin;
+
+    segmentationImageData.setOrigin(originToUse);
+    segmentationImageData.modified();
+
+    if (
+      segmentationImageData.getDimensions()[0] !== dimensions[0] ||
+      segmentationImageData.getDimensions()[1] !== dimensions[1]
+    ) {
+      // IMPORTANT: Not sure why we can't just update the dimensions
+      // and the orientation of the image data and then call modified
+      // I tried calling modified on everything, but seems like we should remove
+      // and add the actor again below
+      viewport.removeActors([actor.uid]);
+      viewport.addImages([
+        {
+          imageId: derivedImageId,
+          actorUID: actor.uid,
+          callback: ({ imageActor }) => {
+            const scalarArray = vtkDataArray.newInstance({
+              name: 'Pixels',
+              numberOfComponents: 1,
+              values: [...derivedImage.getPixelData()],
+            });
+
+            const imageData = vtkImageData.newInstance();
+
+            imageData.setDimensions(dimensions[0], dimensions[1], 1);
+            imageData.setSpacing(spacing);
+            imageData.setDirection(direction);
+            imageData.setOrigin(originToUse);
+            imageData.getPointData().setScalars(scalarArray);
+
+            imageActor.getMapper().setInputData(imageData);
+          },
+        },
+      ]);
+
+      triggerSegmentationRender(toolGroup.id);
+      return;
+    }
+
+    if (segmentationImageData.setDerivedImage) {
+      // Update the derived image data, whether vtk or other as appropriate
+      // to the actor(s) displaying the data.
+      segmentationImageData.setDerivedImage(derivedImage);
+    } else {
+      // TODO - use setDerivedImage for this functionality
+      utilities.updateVTKImageDataWithCornerstoneImage(
+        segmentationImageData,
+        derivedImage
+      );
+    }
+    viewport.render();
+
+    // This is put here to make sure that the segmentation is rendered
+    // for the initial image as well after that we don't need it since
+    // stack new image is called when changing slices
+    if (evt.type === Enums.Events.IMAGE_RENDERED) {
+      // unsubscribe after the initial render
+      viewport.element.removeEventListener(
+        Enums.Events.IMAGE_RENDERED,
+        _imageChangeEventListener as EventListener
+      );
+    }
+  });
+}
+
+export default {
+  enable,
+  disable,
+};

package/src/eventListeners/segmentation/index.ts

@@ -2,10 +2,12 @@ import segmentationRepresentationModifiedEventListener from './segmentationRepre
 import segmentationDataModifiedEventListener from './segmentationDataModifiedEventListener';
 import segmentationRepresentationRemovedEventListener from './segmentationRepresentationRemovedEventListener';
 import segmentationModifiedListener from './segmentationModifiedEventListener';
+import imageChangeEventListener from './imageChangeEventListener';
 
 export {
   segmentationRepresentationModifiedEventListener,
   segmentationDataModifiedEventListener,
   segmentationRepresentationRemovedEventListener,
   segmentationModifiedListener,
+  imageChangeEventListener,
 };

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

@@ -0,0 +1,145 @@
+import {
+  cache,
+  getEnabledElementByIds,
+  utilities as csUtils,
+  VolumeViewport,
+} from '@cornerstonejs/core';
+
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { SegmentationDataModifiedEventType } from '../../../types/EventTypes';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../types/LabelmapTypes';
+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);
+
+  const labelmapRepresentationData = representationData[type];
+
+  if ('volumeId' in labelmapRepresentationData) {
+    // get the volume from cache, we need the openGLTexture to be updated to GPU
+    performVolumeLabelmapUpdate({
+      modifiedSlicesToUse,
+      representationData,
+      type,
+    });
+  }
+
+  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 { 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();
+}
+
+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;
+        }
+
+        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,9 +1,8 @@
-import { cache } 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 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.
@@ -11,46 +10,14 @@ import { SegmentationDataModifiedEventType } from '../../types/EventTypes';
 const onSegmentationDataModified = function (
   evt: SegmentationDataModifiedEventType
 ): void {
-  const { segmentationId, modifiedSlicesToUse } = evt.detail;
+  const { segmentationId } = evt.detail;
+  const { type } = SegmentationState.getSegmentation(segmentationId);
 
-  const { representationData, type } =
-    SegmentationState.getSegmentation(segmentationId);
+  const toolGroupIds =
+    SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
 
-  let toolGroupIds;
   if (type === SegmentationRepresentations.Labelmap) {
-    // get the volume from cache, we need the openGLTexture to be updated to GPU
-    const segmentationVolume = cache.getVolume(
-      representationData[type].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();
-    toolGroupIds =
-      SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
-  } else {
-    throw new Error(
-      `onSegmentationDataModified: representationType ${type} not supported yet`
-    );
+    onLabelmapSegmentationDataModified(evt);
   }
 
   toolGroupIds.forEach((toolGroupId) => {

package/src/eventListeners/touch/touchStartListener.ts

@@ -28,7 +28,7 @@ const {
   TOUCH_SWIPE,
 } = Events;
 
-interface ITouchTapListnenerState {
+interface ITouchTapListenerState {
   element: HTMLDivElement;
   renderingEngineId: string;
   viewportId: string;
@@ -110,7 +110,7 @@ const defaultState: ITouchStartListenerState = {
 // as pen, left/right handed, index finger vs thumb, etc. These current values
 // assume thumb usage for single finger and index/middle finger for two finger
 // gestures in an attempt to cover the 90% use case.
-const defaultTapState: ITouchTapListnenerState = {
+const defaultTapState: ITouchTapListenerState = {
   renderingEngineId: undefined,
   viewportId: undefined,
   element: null,
@@ -127,18 +127,11 @@ const defaultTapState: ITouchTapListnenerState = {
 };
 
 let state: ITouchStartListenerState = JSON.parse(JSON.stringify(defaultState));
-let tapState: ITouchTapListnenerState = JSON.parse(
+let tapState: ITouchTapListenerState = JSON.parse(
   JSON.stringify(defaultTapState)
 );
 
 function triggerEventCallback(ele, name, eventDetail) {
-  if (runtimeSettings.get('debug')) {
-    if (name === 'CORNERSTONE_TOOLS_TOUCH_DRAG') {
-      console.debug(name);
-    } else {
-      console.debug(name, eventDetail);
-    }
-  }
   return triggerEvent(ele, name, eventDetail);
 }
 

package/src/index.ts

@@ -39,9 +39,15 @@ import {
   RectangleROITool,
   EllipticalROITool,
   CircleROITool,
+  SplineROITool,
+  SplineContourSegmentationTool,
   BidirectionalTool,
   PlanarFreehandROITool,
+  PlanarFreehandContourSegmentationTool,
+  LivewireContourTool,
+  LivewireContourSegmentationTool,
   ArrowAnnotateTool,
+  KeyImageTool,
   CrosshairsTool,
   ReferenceLinesTool,
   RectangleScissorsTool,
@@ -49,10 +55,12 @@ import {
   SphereScissorsTool,
   RectangleROIThresholdTool,
   RectangleROIStartEndThresholdTool,
+  CircleROIStartEndThresholdTool,
   SegmentationDisplayTool,
   BrushTool,
   AngleTool,
   CobbAngleTool,
+  UltrasoundDirectionalTool,
   MagnifyTool,
   AdvancedMagnifyTool,
   ReferenceCursors,
@@ -61,11 +69,19 @@ import {
   ScaleOverlayTool,
   OrientationMarkerTool,
   OverlayGridTool,
+  SegmentationIntersectionTool,
+  EraserTool,
+  SculptorTool,
+  SegmentSelectTool,
+  WindowLevelRegionTool,
 } from './tools';
 
+import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
+
 import * as Enums from './enums';
 
 export {
+  VideoRedactionTool,
   //
   init,
   destroy,
@@ -81,6 +97,7 @@ export {
   TrackballRotateTool,
   DragProbeTool,
   WindowLevelTool,
+  WindowLevelRegionTool,
   ZoomTool,
   StackScrollTool,
   PlanarRotateTool,
@@ -92,20 +109,30 @@ export {
   CrosshairsTool,
   ReferenceLinesTool,
   OverlayGridTool,
+  SegmentationIntersectionTool,
   ProbeTool,
   RectangleROITool,
   EllipticalROITool,
   CircleROITool,
+  SplineROITool,
+  SplineContourSegmentationTool,
   BidirectionalTool,
   PlanarFreehandROITool,
+  PlanarFreehandContourSegmentationTool,
+  LivewireContourTool,
+  LivewireContourSegmentationTool,
   ArrowAnnotateTool,
   AngleTool,
   CobbAngleTool,
+  UltrasoundDirectionalTool,
+  KeyImageTool,
   MagnifyTool,
   AdvancedMagnifyTool,
   ReferenceCursors,
   ReferenceLines,
   ScaleOverlayTool,
+  SculptorTool,
+  EraserTool,
   // Segmentation Display
   SegmentationDisplayTool,
   // Segmentation Editing Tools
@@ -114,8 +141,10 @@ export {
   SphereScissorsTool,
   RectangleROIThresholdTool,
   RectangleROIStartEndThresholdTool,
+  CircleROIStartEndThresholdTool,
   BrushTool,
   OrientationMarkerTool,
+  SegmentSelectTool,
   // Synchronizers
   synchronizers,
   Synchronizer,

package/src/init.ts

@@ -5,13 +5,16 @@ import { Events as TOOLS_EVENTS } from './enums';
 import { addEnabledElement, removeEnabledElement } from './store';
 import { resetCornerstoneToolsState } from './store/state';
 import {
+  annotationCompletedListener,
+  annotationRemovedListener,
   annotationSelectionListener,
+  annotationModifiedListener,
   segmentationDataModifiedEventListener,
   segmentationRepresentationModifiedEventListener,
   segmentationRepresentationRemovedEventListener,
   segmentationModifiedListener,
-  annotationModifiedListener,
 } from './eventListeners';
+import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 
 import * as ToolGroupManager from './store/ToolGroupManager';
 
@@ -74,6 +77,7 @@ function _addCornerstoneEventListeners(): void {
 
   eventTarget.addEventListener(elementEnabledEvent, addEnabledElement);
   eventTarget.addEventListener(elementDisabledEvent, removeEnabledElement);
+  annotationInterpolationEventDispatcher.enable();
 }
 
 /**
@@ -87,6 +91,7 @@ function _removeCornerstoneEventListeners(): void {
 
   eventTarget.removeEventListener(elementEnabledEvent, addEnabledElement);
   eventTarget.removeEventListener(elementDisabledEvent, removeEnabledElement);
+  annotationInterpolationEventDispatcher.disable();
 }
 
 /**
@@ -100,6 +105,11 @@ function _addCornerstoneToolsEventListeners() {
   /**
    * Annotation
    */
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_COMPLETED,
+    annotationCompletedListener
+  );
+
   eventTarget.addEventListener(
     TOOLS_EVENTS.ANNOTATION_MODIFIED,
     annotationModifiedListener
@@ -115,6 +125,11 @@ function _addCornerstoneToolsEventListeners() {
     annotationSelectionListener
   );
 
+  eventTarget.addEventListener(
+    TOOLS_EVENTS.ANNOTATION_REMOVED,
+    annotationRemovedListener
+  );
+
   /**
    * Segmentation
    */
@@ -145,6 +160,11 @@ function _removeCornerstoneToolsEventListeners() {
   /**
    * Annotation
    */
+  eventTarget.removeEventListener(
+    TOOLS_EVENTS.ANNOTATION_COMPLETED,
+    annotationCompletedListener
+  );
+
   eventTarget.removeEventListener(
     TOOLS_EVENTS.ANNOTATION_MODIFIED,
     annotationModifiedListener