@cornerstonejs/tools 1.42.0 → 1.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.42.0",
+  "version": "1.43.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,13 +29,13 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.42.0",
+    "@cornerstonejs/core": "^1.43.0",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
   "peerDependencies": {
-    "@kitware/vtk.js": "27.3.1",
+    "@kitware/vtk.js": "29.3.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
     "d3-array": "^3.2.3",
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "75102c80b6bc3714f00590b92ccd8d4d52bf1ca2"
+  "gitHead": "1681f72fb2df75001f844a2e1728f2e9b79b6985"
 }

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/index.ts

@@ -66,6 +66,7 @@ import {
   OrientationMarkerTool,
   OverlayGridTool,
   SegmentationIntersectionTool,
+  SegmentSelectTool,
 } from './tools';
 
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
@@ -129,6 +130,7 @@ export {
   RectangleROIStartEndThresholdTool,
   BrushTool,
   OrientationMarkerTool,
+  SegmentSelectTool,
   // Synchronizers
   synchronizers,
   Synchronizer,

package/src/stateManagement/segmentation/activeSegmentation.ts

@@ -1,5 +1,8 @@
 import { ToolGroupSpecificRepresentation } from '../../types/SegmentationStateTypes';
-import { getDefaultSegmentationStateManager } from './segmentationState';
+import {
+  getDefaultSegmentationStateManager,
+  getSegmentation,
+} from './segmentationState';
 import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
 
 /**
@@ -27,6 +30,25 @@ function getActiveSegmentationRepresentation(
   return activeRepresentation;
 }
 
+/**
+ * Retrieves the active segmentation for a given tool group.
+ * @param toolGroupId - The ID of the tool group.
+ * @returns The active segmentation Id, or undefined if no active segmentation is found.
+ */
+function getActiveSegmentation(toolGroupId: string) {
+  const activeRepresentation = getActiveSegmentationRepresentation(toolGroupId);
+
+  if (!activeRepresentation) {
+    return;
+  }
+
+  const activeSegmentation = getSegmentation(
+    activeRepresentation.segmentationId
+  );
+
+  return activeSegmentation;
+}
+
 /**
  * Set the active segmentation for the given tool group for all its viewports
  *
@@ -55,6 +77,7 @@ function setActiveSegmentationRepresentation(
 export {
   // get
   getActiveSegmentationRepresentation,
+  getActiveSegmentation,
   // set
   setActiveSegmentationRepresentation,
 };

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/segmentIndex.ts

@@ -1,9 +1,15 @@
-import { getSegmentation } from './segmentationState';
+import { invalidateBrushCursor } from '../../utilities/segmentation/';
+import {
+  getSegmentation,
+  getToolGroupIdsWithSegmentation,
+} from './segmentationState';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 
 /**
  * Set the active segment index for a segmentation Id. It fires a global state
- * modified event.
+ * modified event. Also it invalidates the brush cursor for all toolGroups that
+ * has the segmentationId as active segment (since the brush cursor color
+ * should change as well)
  *
  * @triggers SEGMENTATION_MODIFIED
  * @param segmentationId - The id of the segmentation that the segment belongs to.
@@ -20,6 +26,13 @@ function setActiveSegmentIndex(
 
     triggerSegmentationModified(segmentationId);
   }
+
+  // get all toolGroups that has the segmentationId as active
+  // segment and call invalidateBrushCursor on them
+  const toolGroups = getToolGroupIdsWithSegmentation(segmentationId);
+  toolGroups.forEach((toolGroupId) => {
+    invalidateBrushCursor(toolGroupId);
+  });
 }
 
 /**

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 {

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/labelmapConfig.ts

@@ -4,6 +4,7 @@ const defaultLabelmapConfig: LabelmapConfig = {
   renderOutline: true,
   outlineWidthActive: 3,
   outlineWidthInactive: 2,
+  activeSegmentOutlineWidthDelta: 0,
   renderFill: true,
   renderFillInactive: true,
   fillAlpha: 0.7,
@@ -24,6 +25,7 @@ function isValidLabelmapConfig(config): boolean {
     typeof config.renderOutline === 'boolean' &&
     typeof config.outlineWidthActive === 'number' &&
     typeof config.outlineWidthInactive === 'number' &&
+    typeof config.activeSegmentOutlineWidthDelta === 'number' &&
     typeof config.renderFill === 'boolean' &&
     typeof config.renderFillInactive === 'boolean' &&
     typeof config.fillAlpha === 'number' &&