@cornerstonejs/tools 1.41.0 → 1.42.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.41.0",
+  "version": "1.42.1",
   "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.41.0",
+    "@cornerstonejs/core": "^1.42.1",
     "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": "a151cd133119685c23a9aa7b739e5b7a55312bd1"
+  "gitHead": "14a1bff3ba983b6664529e8e829a655cc4ffda89"
 }

package/src/eventDispatchers/keyboardEventHandlers/keyDown.ts

@@ -34,7 +34,13 @@ export default function keyDown(evt: KeyDownEventType): void {
   if (activeToolsWithEventBinding?.size) {
     const { element } = evt.detail;
     for (const [key, value] of [...activeToolsWithEventBinding.entries()]) {
-      key[value.method](element);
+      // Calls the method that implements the action, which can be a string
+      // in which case it belongs to the tool instance, or a function
+      // Call it on the tool instance, with the element and configuration value
+      // so that the method can depend on the specific configuration in use.
+      const method =
+        typeof value.method === 'function' ? value.method : key[value.method];
+      method.call(key, element, value);
     }
   }
 }

package/src/eventListeners/segmentation/imageChangeEventListener.ts

@@ -1,3 +1,5 @@
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import {
   StackViewport,
   getEnabledElement,
@@ -6,15 +8,12 @@ import {
   cache,
   utilities,
   Types,
-  metaData,
 } 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 vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
 
 const enable = function (element: HTMLDivElement): void {
@@ -118,6 +117,26 @@ function _imageChangeEventListener(evt) {
   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.
+    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;
@@ -148,10 +167,27 @@ function _imageChangeEventListener(evt) {
 
     const derivedImage = cache.getImage(derivedImageId);
 
-    const { origin, dimensions, spacing, direction } =
+    const { dimensions, spacing, direction } =
       viewport.getImageDataMetadata(derivedImage);
 
-    segmentationImageData.setOrigin(origin);
+    const currentImage = cache.getImage(currentImageId);
+    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 (
@@ -180,7 +216,7 @@ function _imageChangeEventListener(evt) {
               imageData.setDimensions(dimensions[0], dimensions[1], 1);
               imageData.setSpacing(spacing);
               imageData.setDirection(direction);
-              imageData.setOrigin(origin);
+              imageData.setOrigin(originToUse);
               imageData.getPointData().setScalars(scalarArray);
 
               imageActor.getMapper().setInputData(imageData);

package/src/stateManagement/annotation/annotationState.ts

@@ -126,6 +126,9 @@ function getNumberOfAnnotations(
  * @param annotationUID - The unique identifier for the annotation.
  */
 function removeAnnotation(annotationUID: string): void {
+  if (!annotationUID) {
+    return;
+  }
   const manager = getAnnotationManager();
   const annotation = manager.getAnnotation(annotationUID);
 

package/src/stateManagement/segmentation/convertStackToVolumeSegmentation.ts

@@ -0,0 +1,98 @@
+import {
+  volumeLoader,
+  utilities as csUtils,
+  eventTarget,
+} 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 { LabelmapSegmentationDataStack } from '../../types/LabelmapTypes';
+import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
+
+/**
+ * Converts a stack-based segmentation to a volume-based segmentation.
+ *
+ * @param params - The parameters for the conversion.
+ * @param params.segmentationId - The segmentationId to convert.
+ * @param [params.options] - The conversion options.
+ * @param params.options.toolGroupId - The new toolGroupId to use for the segmentation.
+ * @param [params.options.volumeId] - the new volumeId to use for the segmentation. If not provided, a new ID will be generated.
+ * @param [params.options.newSegmentationId] - the new segmentationId to use for the segmentation. If not provided, a new ID will be generated.
+ * @param [params.options.removeOriginal] - Whether or not to remove the original segmentation. Defaults to true.
+ *
+ * @returns A promise that resolves when the conversion is complete.
+ */
+async function convertStackToVolumeSegmentation({
+  segmentationId,
+  options,
+}: {
+  segmentationId: string;
+  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;
+
+  // Get the imageIds from the imageIdReferenceMap
+  const segmentationImageIds = Array.from(imageIdReferenceMap.values());
+
+  const additionalDetails = {
+    imageIdReferenceMap,
+  };
+
+  // Since segmentations are already cached and are not
+  // loaded like volumes, we can create a volume out of their images
+  const volumeId = options?.volumeId;
+
+  await volumeLoader.createAndCacheVolumeFromImages(
+    volumeId,
+    segmentationImageIds,
+    {
+      additionalDetails,
+    }
+  );
+
+  const newSegmentationId = options?.newSegmentationId ?? csUtils.uuidv4();
+
+  if (options?.removeOriginal ?? true) {
+    removeSegmentation(segmentationId);
+  }
+
+  await addSegmentations([
+    {
+      segmentationId: newSegmentationId,
+      representation: {
+        type: SegmentationRepresentations.Labelmap,
+        data: {
+          volumeId,
+        },
+      },
+    },
+  ]);
+
+  await addSegmentationRepresentations(toolGroupId, [
+    {
+      segmentationId: newSegmentationId,
+      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)
+  );
+}
+
+export { convertStackToVolumeSegmentation };

package/src/stateManagement/segmentation/convertVolumeToStackSegmentation.ts

@@ -0,0 +1,153 @@
+import {
+  Types,
+  cache,
+  utilities as csUtils,
+  eventTarget,
+} 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 { LabelmapSegmentationDataVolume } from '../../types/LabelmapTypes';
+import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
+
+/**
+ * Converts a volume segmentation to a stack segmentation.
+ *
+ * @param params - The parameters for the conversion.
+ * @param params.segmentationId - The segmentationId to convert.
+ * @param [params.options] - The conversion options.
+ * @param params.options.toolGroupId - The new toolGroupId that the new segmentation will belong to.
+ * @param [params.options.newSegmentationId] -  The new segmentationId to use for the segmentation. If not provided, a new ID will be generated.
+ * @param [params.options.removeOriginal] - Whether or not to remove the original segmentation. Defaults to true.
+ *
+ * @returns A promise that resolves when the conversion is complete.
+ */
+export async function convertVolumeToStackSegmentation({
+  segmentationId,
+  options,
+}: {
+  segmentationId: string;
+  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;
+
+  const imageIdReferenceMap =
+    _getImageIdReferenceMapForStackSegmentation(segmentationVolume);
+
+  const newSegmentationId = options?.newSegmentationId ?? csUtils.uuidv4();
+
+  if (options?.removeOriginal ?? true) {
+    removeSegmentation(segmentationId);
+  }
+
+  await addSegmentations([
+    {
+      segmentationId: newSegmentationId,
+      representation: {
+        type: SegmentationRepresentations.Labelmap,
+        data: {
+          imageIdReferenceMap,
+        },
+      },
+    },
+  ]);
+  // Add the segmentation representation to the toolgroup
+  await addSegmentationRepresentations(toolGroupId, [
+    {
+      segmentationId: newSegmentationId,
+      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)
+  );
+}
+
+function _getImageIdReferenceMapForStackSegmentation(
+  segmentationVolume: Types.IImageVolume
+) {
+  // There might be or might not be segmentationImageIds, if it is a volume
+  // 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
+    // and we can use the imageIdReferenceMap from the additionalDetails
+    return segmentationVolume.additionalDetails.imageIdReferenceMap;
+  } else if (
+    segmentationVolume.referencedImageIds?.length &&
+    !segmentationVolume.referencedImageIds[0].startsWith('derived')
+  ) {
+    // this means the segmentation volume is derived from a stack segmentation
+    // and we can use the referencedImageIds from the segmentationVolume
+    const referencedImageIds = segmentationVolume.referencedImageIds;
+
+    return createImageIdReferenceMap(referencedImageIds, segmentationImageIds);
+  } else {
+    // check if the segmentation volume is derived from another volume and
+    // whether if that volume has imageIds
+    const referencedVolumeId = segmentationVolume.referencedVolumeId;
+    const referencedVolume = cache.getVolume(referencedVolumeId);
+
+    if (!referencedVolume) {
+      throw new Error(
+        'Cannot convert volumetric segmentation without referenced volume to stack segmentation yet'
+      );
+    }
+
+    if (!referencedVolume?.imageIds?.length) {
+      throw new Error(
+        'Cannot convert volumetric segmentation without imageIds to stack segmentation yet'
+      );
+    }
+
+    if (referencedVolume.imageIds?.[0].startsWith('derived')) {
+      throw new Error(
+        `Cannot convert volume segmentation that is derived from another segmentation
+         to stack segmentation yet, include the additionalDetails.imageIdReferenceMap
+         in the volume segmentation in case you need it for the conversion`
+      );
+    }
+
+    // if the referenced volume has imageIds, and itself is not derived from
+    // another segmentation then we can use the imageIds from the referenced volume
+    const referencedImageIds = referencedVolume.imageIds;
+
+    let segmentationImageIdsToUse = segmentationVolume.imageIds;
+    if (!segmentationImageIdsToUse?.length) {
+      // If segmentation Ids don't exist it means that the segmentation is literally
+      // just a volume so we need to assume imageIds and decache it to the _imageCache
+      // so that it can be used for the conversion
+      segmentationImageIdsToUse =
+        segmentationVolume.convertToImageSlicesAndCache();
+    }
+
+    return createImageIdReferenceMap(
+      referencedImageIds,
+      segmentationImageIdsToUse
+    );
+  }
+}

package/src/stateManagement/segmentation/index.ts

@@ -1,6 +1,8 @@
 import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
 import addSegmentations from './addSegmentations';
 import addSegmentationRepresentations from './addSegmentationRepresentations';
+import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
+import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
 
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -19,4 +21,6 @@ export {
   config,
   segmentIndex,
   triggerSegmentationEvents,
+  convertStackToVolumeSegmentation,
+  convertVolumeToStackSegmentation,
 };

package/src/stateManagement/segmentation/segmentationState.ts

@@ -368,6 +368,22 @@ function removeSegmentationRepresentation(
   );
 }
 
+/**
+ * Removes all segmentation representations associated with a tool group.
+ * @param toolGroupId - The ID of the tool group.
+ */
+function removeSegmentationRepresentations(toolGroupId: string): void {
+  const segmentationRepresentations =
+    getSegmentationRepresentations(toolGroupId) || [];
+
+  segmentationRepresentations.forEach((representation) => {
+    removeSegmentationRepresentation(
+      toolGroupId,
+      representation.segmentationRepresentationUID
+    );
+  });
+}
+
 /**
  * Add a color LUT to the segmentation state manager
  * @param colorLUT - The color LUT array to add.
@@ -415,6 +431,7 @@ export {
   getSegmentationRepresentations,
   addSegmentationRepresentation,
   removeSegmentationRepresentation,
+  removeSegmentationRepresentations,
   // config
   getToolGroupSpecificConfig,
   setToolGroupSpecificConfig,

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -185,6 +185,10 @@ export default class ToolGroup implements IToolGroup {
    * @param renderingEngineId - The rendering engine to use.
    */
   public addViewport(viewportId: string, renderingEngineId?: string): void {
+    if (typeof viewportId !== 'string') {
+      throw new Error('viewportId must be defined and be a string');
+    }
+
     const renderingEngines = getRenderingEngines();
 
     if (!renderingEngineId && renderingEngines.length > 1) {

package/src/tools/annotation/AngleTool.ts

@@ -16,7 +16,7 @@ import {
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import * as lineSegment from '../../utilities/math/line';
 import angleBetweenLines from '../../utilities/math/angle/angleBetweenLines';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 
 import {
   drawHandles as drawHandlesSvg,
@@ -25,7 +25,6 @@ import {
 } from '../../drawingSvg';
 import { state } from '../../store';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import {
   AnnotationCompletedEventDetail,

package/src/tools/annotation/BidirectionalTool.ts

@@ -11,7 +11,7 @@ import {
   getCalibratedLengthUnits,
   getCalibratedScale,
 } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import {
@@ -1348,19 +1348,23 @@ class BidirectionalTool extends AnnotationTool {
 }
 
 function defaultGetTextLines(data, targetId): string[] {
-  const { cachedStats } = data;
+  const { cachedStats, label } = data;
   const { length, width, unit } = cachedStats[targetId];
 
+  const textLines = [];
+  if (label) {
+    textLines.push(label);
+  }
   if (length === undefined) {
-    return;
+    return textLines;
   }
 
   // spaceBetweenSlices & pixelSpacing &
   // magnitude in each direction? Otherwise, this is "px"?
-  const textLines = [
+  textLines.push(
     `L: ${roundNumber(length)} ${unit}`,
-    `W: ${roundNumber(width)} ${unit}`,
-  ];
+    `W: ${roundNumber(width)} ${unit}`
+  );
 
   return textLines;
 }

package/src/tools/annotation/CircleROITool.ts

@@ -15,7 +15,7 @@ import {
   getCalibratedScale,
   getCalibratedAspect,
 } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,

package/src/tools/annotation/EllipticalROITool.ts

@@ -13,7 +13,7 @@ import {
   getCalibratedAreaUnits,
   getCalibratedScale,
 } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,

package/src/tools/annotation/LengthTool.ts

@@ -8,7 +8,7 @@ import {
 import type { Types } from '@cornerstonejs/core';
 
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import {

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -3,7 +3,6 @@ import {
   getEnabledElement,
   triggerEvent,
   eventTarget,
-  StackViewport,
   VolumeViewport,
   utilities as csUtils,
 } from '@cornerstonejs/core';
@@ -14,7 +13,7 @@ import {
   getCalibratedAreaUnits,
   getCalibratedScale,
 } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import { Events } from '../../enums';
 import { AnnotationTool } from '../base';
 import {

package/src/tools/annotation/ProbeTool.ts

@@ -24,7 +24,7 @@ import {
 import { state } from '../../store';
 import { Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import {
   resetElementCursor,
   hideElementCursor,

package/src/tools/annotation/RectangleROITool.ts

@@ -13,7 +13,7 @@ import {
   getCalibratedAreaUnits,
   getCalibratedScale,
 } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,

package/src/tools/displayTools/Labelmap/labelmapDisplay.ts

@@ -4,12 +4,13 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import {
   cache,
   getEnabledElementByIds,
+  StackViewport,
   Types,
   utilities,
+  VolumeViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { getToolGroup } from '../../../store/ToolGroupManager';
 import type {
@@ -18,7 +19,6 @@ import type {
   LabelmapSegmentationData,
 } from '../../../types/LabelmapTypes';
 import {
-  RepresentationPublicInput,
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
@@ -131,11 +131,21 @@ async function render(
   } = representation;
 
   const segmentation = SegmentationState.getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    console.warn('No segmentation found for segmentationId: ', segmentationId);
+    return;
+  }
+
   const labelmapData =
     segmentation.representationData[Representations.Labelmap];
 
   let actorEntry = viewport.getActor(segmentationRepresentationUID);
   if (isVolumeSegmentation(labelmapData)) {
+    if (viewport instanceof StackViewport) {
+      return;
+    }
+
     const { volumeId: labelmapUID } = labelmapData;
 
     const labelmap = cache.getVolume(labelmapUID);
@@ -159,6 +169,10 @@ async function render(
 
     actorEntry = viewport.getActor(segmentationRepresentationUID);
   } else {
+    if (viewport instanceof VolumeViewport) {
+      return;
+    }
+
     // stack segmentation
     const imageId = viewport.getCurrentImageId();
     const { imageIdReferenceMap } = labelmapData;