@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/tools/displayTools/registerDisplayToolsWorker.ts

@@ -0,0 +1,34 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+
+let registered = false;
+
+export function registerDisplayToolsWorker() {
+  if (registered) {
+    return;
+  }
+
+  registered = true;
+
+  const workerFn = () => {
+    // @ts-ignore
+    return new Worker(
+      // @ts-ignore
+      new URL('../../workers/clippingPlaneWorker', import.meta.url),
+      {
+        name: 'displayTools',
+      }
+    );
+  };
+
+  const workerManager = getWebWorkerManager();
+
+  const options = {
+    maxWorkerInstances: 1, // Todo, make this configurable
+    autoTerminateOnIdle: {
+      enabled: true,
+      idleTimeThreshold: 2000,
+    },
+  };
+
+  workerManager.registerWorker('displayTools', workerFn, options);
+}

package/src/tools/segmentation/BrushTool.ts

@@ -198,7 +198,7 @@ class BrushTool extends BaseTool {
     const labelmapData =
       representationData[SegmentationRepresentations.Labelmap];
 
-    if (isVolumeSegmentation(labelmapData)) {
+    if (isVolumeSegmentation(labelmapData, viewport)) {
       const { volumeId } = representationData[
         type
       ] as LabelmapSegmentationDataVolume;

package/src/tools/segmentation/CircleScissorsTool.ts

@@ -180,7 +180,9 @@ class CircleScissorsTool extends BaseTool {
       segmentationRepresentationUID,
     } as any;
 
-    if (isVolumeSegmentation(labelmapData as LabelmapSegmentationData)) {
+    if (
+      isVolumeSegmentation(labelmapData as LabelmapSegmentationData, viewport)
+    ) {
       const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
       const segmentation = cache.getVolume(volumeId);
 

package/src/tools/segmentation/PaintFillTool.ts

@@ -95,7 +95,7 @@ class PaintFillTool extends BaseTool {
     let scalarData: Types.PixelDataTypedArray;
     let index: Types.Point3;
 
-    if (isVolumeSegmentation(labelmapData)) {
+    if (isVolumeSegmentation(labelmapData, viewport)) {
       const { volumeId } = representationData[
         type
       ] as LabelmapSegmentationDataVolume;

package/src/tools/segmentation/RectangleScissorsTool.ts

@@ -179,7 +179,9 @@ class RectangleScissorsTool extends BaseTool {
       segmentationRepresentationUID,
     } as any;
 
-    if (isVolumeSegmentation(labelmapData as LabelmapSegmentationData)) {
+    if (
+      isVolumeSegmentation(labelmapData as LabelmapSegmentationData, viewport)
+    ) {
       const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
       const segmentation = cache.getVolume(volumeId);
 

package/src/tools/segmentation/SegmentSelectTool.ts

@@ -1,8 +1,4 @@
-import {
-  cache,
-  getEnabledElement,
-  utilities as csUtils,
-} from '@cornerstonejs/core';
+import { getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { BaseTool } from '../base';
@@ -10,21 +6,20 @@ import {
   PublicToolProps,
   ToolProps,
   EventTypes,
-  Segmentation,
+  ToolGroupSpecificRepresentation,
 } from '../../types';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import {
-  LabelmapSegmentationDataStack,
-  LabelmapSegmentationDataVolume,
-} from '../../types/LabelmapTypes';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import {
-  getActiveSegmentation,
-  getActiveSegmentationRepresentation,
-} from '../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
+import {
+  getHoveredContourSegmentationAnnotation,
+  getSegmentAtLabelmapBorder,
+  getSegmentAtWorldPoint,
+} from '../../utilities/segmentation';
+import { state } from '../../store';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 
 /**
  * Represents a tool used for segment selection. It is used to select a segment
@@ -35,12 +30,19 @@ class SegmentSelectTool extends BaseTool {
   static toolName;
   private hoverTimer: ReturnType<typeof setTimeout> | null;
 
+  static SelectMode = {
+    Inside: 'Inside',
+    Border: 'Border',
+  };
+
   constructor(
     toolProps: PublicToolProps = {},
     defaultToolProps: ToolProps = {
       supportedInteractionTypes: ['Mouse', 'Touch'],
       configuration: {
-        hoverTimeout: 750,
+        hoverTimeout: 100,
+        mode: SegmentSelectTool.SelectMode.Border,
+        searchRadius: 6, // search for border in a 6px radius
       },
     }
   ) {
@@ -74,6 +76,10 @@ class SegmentSelectTool extends BaseTool {
   };
 
   _setActiveSegment(evt = {} as EventTypes.InteractionEventType): void {
+    if (state.isInteractingWithTool) {
+      return;
+    }
+
     const { element, currentPoints } = evt.detail;
 
     const worldPoint = currentPoints.world;
@@ -86,17 +92,34 @@ class SegmentSelectTool extends BaseTool {
 
     const { viewport } = enabledElement;
 
-    const activeSegmentation = getActiveSegmentation(this.toolGroupId);
+    const activeSegmentationReps = getActiveSegmentationRepresentation(
+      this.toolGroupId
+    );
+
+    if (!activeSegmentationReps) {
+      return;
+    }
+
+    const supportedTypes = [
+      RepresentationTypes.Labelmap,
+      RepresentationTypes.Contour,
+    ];
 
-    if (activeSegmentation.type === RepresentationTypes.Labelmap) {
-      this._setActiveSegmentLabelmap(activeSegmentation, worldPoint, viewport);
+    if (supportedTypes.includes(activeSegmentationReps.type)) {
+      this._setActiveSegmentForType(
+        activeSegmentationReps,
+        worldPoint,
+        viewport
+      );
     } else {
-      throw Error('non-labelmap segmentation not supported yet');
+      console.warn(
+        'SegmentSelectTool does not support the current segmentation type.'
+      );
     }
   }
 
-  _setActiveSegmentLabelmap(
-    activeSegmentation: Segmentation,
+  _setActiveSegmentForType(
+    activeSegmentationReps: ToolGroupSpecificRepresentation,
     worldPoint: Types.Point3,
     viewport: Types.IStackViewport | Types.IVolumeViewport
   ): void {
@@ -106,55 +129,32 @@ class SegmentSelectTool extends BaseTool {
       return;
     }
 
-    const labelmapData = activeSegmentation.representationData.LABELMAP;
+    const { segmentationId, type } = activeSegmentationReps;
 
     let hoveredSegmentIndex;
 
-    if (isVolumeSegmentation(activeSegmentation.representationData.LABELMAP)) {
-      const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
-
-      const segmentationVolume = cache.getVolume(volumeId);
-
-      if (!segmentationVolume) {
-        return;
-      }
-
-      hoveredSegmentIndex =
-        segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+    if (this.configuration.mode === SegmentSelectTool.SelectMode.Inside) {
+      hoveredSegmentIndex = getSegmentAtWorldPoint(segmentationId, worldPoint, {
+        viewport,
+      });
     } else {
-      const { imageIdReferenceMap } =
-        labelmapData as LabelmapSegmentationDataStack;
-
-      const currentImageId = viewport.getCurrentImageId();
-      const segmentationImageId = imageIdReferenceMap.get(currentImageId);
-
-      const image = cache.getImage(segmentationImageId);
-
-      if (!image) {
-        return;
+      switch (type) {
+        case SegmentationRepresentations.Labelmap:
+          hoveredSegmentIndex = getSegmentAtLabelmapBorder(
+            segmentationId,
+            worldPoint,
+            {
+              viewport,
+              searchRadius: this.configuration.searchRadius,
+            }
+          );
+          break;
+
+        case SegmentationRepresentations.Contour:
+          hoveredSegmentIndex =
+            getHoveredContourSegmentationAnnotation(segmentationId);
+          break;
       }
-
-      const activeSegmentationRepresentation =
-        getActiveSegmentationRepresentation(this.toolGroupId);
-
-      if (!activeSegmentationRepresentation) {
-        return;
-      }
-
-      const segmentationActor = viewport.getActor(
-        activeSegmentationRepresentation.segmentationRepresentationUID
-      );
-
-      const imageData = segmentationActor?.actor.getMapper().getInputData();
-
-      const indexIJK = csUtils.transformWorldToIndex(imageData, worldPoint);
-
-      // since it is a stack we don't need to check the z
-      const flattenedIndex = indexIJK[0] + indexIJK[1] * image.columns;
-
-      const scalars = imageData.getPointData().getScalars().getData();
-
-      hoveredSegmentIndex = scalars[flattenedIndex];
     }
 
     // No need to select background
@@ -162,19 +162,14 @@ class SegmentSelectTool extends BaseTool {
       return;
     }
 
-    setActiveSegmentIndex(
-      activeSegmentation.segmentationId,
-      hoveredSegmentIndex
-    );
+    setActiveSegmentIndex(segmentationId, hoveredSegmentIndex);
 
     const renderingEngine = viewport.getRenderingEngine();
+    const viewportIds = renderingEngine.getViewports().map((v) => v.id);
 
     // update states
-    triggerSegmentationModified(activeSegmentation.segmentationId);
-    triggerAnnotationRenderForViewportIds(
-      renderingEngine,
-      renderingEngine.getViewports().map((v) => v.id)
-    );
+    triggerSegmentationModified(segmentationId);
+    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
   }
 }
 

package/src/tools/segmentation/SphereScissorsTool.ts

@@ -177,7 +177,9 @@ class SphereScissorsTool extends BaseTool {
     const labelmapData =
       representationData[SegmentationRepresentations.Labelmap];
 
-    if (isVolumeSegmentation(labelmapData as LabelmapSegmentationData)) {
+    if (
+      isVolumeSegmentation(labelmapData as LabelmapSegmentationData, viewport)
+    ) {
       const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
       const segmentation = cache.getVolume(volumeId);
 

package/src/tools/segmentation/strategies/BrushStrategy.ts

@@ -196,20 +196,23 @@ export default class BrushStrategy {
       return operationData.preview;
     }
 
-    if (isVolumeSegmentation(operationData)) {
+    if (isVolumeSegmentation(operationData, viewport)) {
       const { referencedVolumeId, volumeId } =
         operationData as LabelmapToolOperationDataVolume;
 
-      const imageVolume = cache.getVolume(referencedVolumeId);
       const segmentation = cache.getVolume(volumeId);
 
-      if (
-        !csUtils.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
-        !csUtils.isEqual(segmentation.direction, imageVolume.direction)
-      ) {
-        throw new Error(
-          'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
-        );
+      if (referencedVolumeId) {
+        const imageVolume = cache.getVolume(referencedVolumeId);
+
+        if (
+          !csUtils.isEqual(segmentation.dimensions, imageVolume.dimensions) ||
+          !csUtils.isEqual(segmentation.direction, imageVolume.direction)
+        ) {
+          throw new Error(
+            'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
+          );
+        }
       }
     }
 

package/src/tools/segmentation/strategies/compositions/regionFill.ts

@@ -35,7 +35,7 @@ export default {
 
     pointInShapeCallback(
       segmentationImageData as unknown,
-      imageVoxelManager.isInObject,
+      imageVoxelManager?.isInObject || segmentationVoxelManager.isInObject,
       callback,
       segmentationVoxelManager.boundsIJK
     );

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -48,11 +48,19 @@ const sphereComposition = {
 
     segmentationVoxelManager.boundsIJK = newBoundsIJK;
 
-    imageVoxelManager.isInObject = createEllipseInPoint({
-      topLeftWorld,
-      bottomRightWorld,
-      center,
-    });
+    if (imageVoxelManager) {
+      imageVoxelManager.isInObject = createEllipseInPoint({
+        topLeftWorld,
+        bottomRightWorld,
+        center,
+      });
+    } else {
+      segmentationVoxelManager.isInObject = createEllipseInPoint({
+        topLeftWorld,
+        bottomRightWorld,
+        center,
+      });
+    }
   },
 } as Composition;
 

package/src/tools/segmentation/strategies/utils/getStrategyData.ts

@@ -7,21 +7,28 @@ const { VoxelManager } = utilities;
 
 function getStrategyData({ operationData, viewport }) {
   let segmentationImageData, segmentationScalarData, imageScalarData;
-  let dimensions: Types.Point3;
-  if (isVolumeSegmentation(operationData)) {
+  let imageDimensions: Types.Point3;
+  let segmentationDimensions: Types.Point3;
+  if (isVolumeSegmentation(operationData, viewport)) {
     const { volumeId, referencedVolumeId } = operationData;
 
     const segmentationVolume = cache.getVolume(volumeId);
-    const imageVolume = cache.getVolume(referencedVolumeId);
 
-    if (!segmentationVolume || !imageVolume) {
+    if (!segmentationVolume) {
       return;
     }
 
+    // we only need the referenceVolumeId if we do thresholding
+    // but for other operations we don't need it so make it optional
+    if (referencedVolumeId) {
+      const imageVolume = cache.getVolume(referencedVolumeId);
+      imageScalarData = imageVolume.getScalarData();
+      imageDimensions = imageVolume.dimensions;
+    }
+
     ({ imageData: segmentationImageData } = segmentationVolume);
     segmentationScalarData = segmentationVolume.getScalarData();
-    imageScalarData = imageVolume.getScalarData();
-    dimensions = imageVolume.dimensions;
+    segmentationDimensions = segmentationVolume.dimensions;
   } else {
     const { imageIdReferenceMap, segmentationRepresentationUID } =
       operationData as LabelmapToolOperationDataStack;
@@ -51,21 +58,29 @@ function getStrategyData({ operationData, viewport }) {
     // This is the pixel data of the image that is being segmented in the cache
     // and we need to use this to for the modification
     imageScalarData = image.getPixelData();
-    dimensions = [image.columns, image.rows, 1];
+    imageDimensions = [image.columns, image.rows, 1];
+    segmentationDimensions = [
+      segmentationImage.columns,
+      segmentationImage.rows,
+      1,
+    ];
   }
 
+  const segmentationVoxelManager = VoxelManager.createVolumeVoxelManager(
+    segmentationDimensions,
+    segmentationScalarData
+  );
+
+  const imageVoxelManager =
+    imageDimensions &&
+    VoxelManager.createVolumeVoxelManager(imageDimensions, imageScalarData);
+
   return {
     segmentationImageData,
     segmentationScalarData,
-    segmentationVoxelManager: VoxelManager.createVolumeVoxelManager(
-      dimensions,
-      segmentationScalarData
-    ),
+    segmentationVoxelManager,
     imageScalarData,
-    imageVoxelManager: VoxelManager.createVolumeVoxelManager(
-      dimensions,
-      imageScalarData
-    ),
+    imageVoxelManager,
   };
 }
 

package/src/tools/segmentation/strategies/utils/stackVolumeCheck.ts

@@ -1,6 +1,5 @@
 import {
   LabelmapSegmentationData,
-  LabelmapSegmentationDataStack,
   LabelmapSegmentationDataVolume,
 } from '../../../../types/LabelmapTypes';
 import {
@@ -8,26 +7,34 @@ import {
   LabelmapToolOperationDataStack,
   LabelmapToolOperationDataVolume,
 } from '../../../../types';
-
-function isStackSegmentation(
-  operationData: LabelmapToolOperationData | LabelmapSegmentationData
-): operationData is
-  | LabelmapToolOperationDataStack
-  | LabelmapSegmentationDataStack {
-  return (
-    (operationData as LabelmapToolOperationDataStack).imageIdReferenceMap !==
-    undefined
-  );
-}
+import { Types, VolumeViewport } from '@cornerstonejs/core';
 
 function isVolumeSegmentation(
-  operationData: LabelmapToolOperationData | LabelmapSegmentationData
+  operationData: LabelmapToolOperationData | LabelmapSegmentationData,
+  viewport?: Types.IViewport
 ): operationData is
   | LabelmapToolOperationDataVolume
   | LabelmapSegmentationDataVolume {
-  return (
-    (operationData as LabelmapToolOperationDataVolume)?.volumeId !== undefined
-  );
+  const { imageIdReferenceMap } =
+    operationData as LabelmapToolOperationDataStack;
+  const { volumeId } = operationData as LabelmapToolOperationDataVolume;
+
+  if (volumeId && !imageIdReferenceMap) {
+    return true;
+  }
+
+  if (imageIdReferenceMap && !volumeId) {
+    return false;
+  }
+
+  if (volumeId && imageIdReferenceMap && !viewport) {
+    throw new Error(
+      'isVolumeSegmentation: viewport is required when both volumeId and imageIdReferenceMap are provided'
+    );
+  }
+
+  // we can get the viewport to decide
+  return viewport instanceof VolumeViewport;
 }
 
-export { isStackSegmentation, isVolumeSegmentation };
+export { isVolumeSegmentation };

package/src/types/ContourSegmentationAnnotation.ts

@@ -8,7 +8,6 @@ export type ContourSegmentationAnnotationData = {
     segmentation: {
       segmentationId: string;
       segmentIndex: number;
-      segmentationRepresentationUID: string;
     };
     contour: {
       /** The original polyline before livewire, to show comparison with

package/src/types/LabelmapTypes.ts

@@ -53,4 +53,10 @@ export type LabelmapSegmentationDataStack = {
 
 export type LabelmapSegmentationData =
   | LabelmapSegmentationDataVolume
-  | LabelmapSegmentationDataStack;
+  | LabelmapSegmentationDataStack
+  // PolySeg version that has both
+  | {
+      volumeId?: string;
+      referencedVolumeId?: string;
+      imageIdReferenceMap?: Map<string, string>;
+    };

package/src/types/PolySeg.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+
+export type PolySegConversionOptions = {
+  segmentIndices?: number[];
+  segmentationRepresentationUID?: string;
+  viewport?: Types.IViewport;
+};

package/src/types/SegmentationStateTypes.ts

@@ -107,6 +107,13 @@ export type ToolGroupSpecificRepresentationState = {
    * using to render
    */
   colorLUTIndex: number;
+  /**
+   * Poly Seg generated
+   */
+  polySeg?: {
+    enabled: boolean;
+    options?: any;
+  };
 };
 
 /**
@@ -266,9 +273,18 @@ export type SegmentationPublicInput = {
 export type RepresentationPublicInput = {
   segmentationId: string;
   type: Enums.SegmentationRepresentations;
-  options?: {
-    // color lut to use for this representation (optional), it can
-    // be either a colorLUT array or the index of the colorLUT in the state
-    colorLUTOrIndex?: Types.ColorLUT | number;
+  options?: RepresentationPublicInputOptions;
+};
+
+export type RepresentationPublicInputOptions = {
+  segmentationRepresentationUID?: string;
+  // color lut to use for this representation (optional), it can
+  // be either a colorLUT array or the index of the colorLUT in the state
+  colorLUTOrIndex?: Types.ColorLUT | number;
+  // whether to use polymorphic segmentation utilities to convert
+  // from other representations to this representation
+  polySeg?: {
+    enabled: boolean;
+    options?: any;
   };
 };

package/src/types/SurfaceTypes.ts

@@ -6,5 +6,5 @@ export type SurfaceRenderingConfig = {
 };
 
 export type SurfaceSegmentationData = {
-  geometryId: string;
+  geometryIds: Map<number, string>;
 };

package/src/types/index.ts

@@ -87,6 +87,7 @@ import type { SplineCurveSegment } from './SplineCurveSegment';
 import type { SplineLineSegment } from './SplineLineSegment';
 import type { SplineProps } from './SplineProps';
 import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
+import type { PolySegConversionOptions } from './PolySeg';
 
 export type {
   // AnnotationState
@@ -174,4 +175,6 @@ export type {
   SplineCurveSegment,
   SplineLineSegment,
   SplineProps,
+  // polySeg
+  PolySegConversionOptions,
 };

package/src/utilities/boundingBox/getBoundingBoxAroundShape.ts

@@ -22,7 +22,9 @@ function calculateBoundingBox(
 
   const is3D = points[0]?.length === 3;
 
-  points.forEach((p) => {
+  // use for loop for performance
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
     xMin = Math.min(p[0], xMin);
     xMax = Math.max(p[0], xMax);
     yMin = Math.min(p[1], yMin);
@@ -32,7 +34,7 @@ function calculateBoundingBox(
       zMin = Math.min(p[2] ?? zMin, zMin);
       zMax = Math.max(p[2] ?? zMax, zMax);
     }
-  });
+  }
 
   if (dimensions) {
     xMin = Math.max(isWorld ? dimensions[0] + EPSILON : 0, xMin);

package/src/utilities/contourSegmentation/addContourSegmentationAnnotation.ts

@@ -0,0 +1,29 @@
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { ContourSegmentationAnnotation } from '../../types';
+
+/**
+ * Adds a contour segmentation annotation to the specified segmentation.
+ * @param annotation - The contour segmentation annotation to add.
+ */
+export function addContourSegmentationAnnotation(
+  annotation: ContourSegmentationAnnotation
+) {
+  if (!annotation.data.segmentation) {
+    throw new Error(
+      'addContourSegmentationAnnotation: annotation does not have a segmentation data'
+    );
+  }
+
+  const { segmentationId, segmentIndex } = annotation.data.segmentation;
+  const segmentation = getSegmentation(segmentationId);
+  const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+
+  let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+
+  if (!annotationsUIDsSet) {
+    annotationsUIDsSet = new Set();
+    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+  }
+
+  annotationsUIDsSet.add(annotation.annotationUID);
+}

package/src/utilities/contourSegmentation/areSameSegment.ts

@@ -17,8 +17,6 @@ export default function areSameSegment(
 
   return (
     firstSegmentation.segmentationId === secondSegmentation.segmentationId &&
-    firstSegmentation.segmentationRepresentationUID ===
-      secondSegmentation.segmentationRepresentationUID &&
     firstSegmentation.segmentIndex === secondSegmentation.segmentIndex
   );
 }

package/src/utilities/contourSegmentation/index.ts

@@ -1,2 +1,4 @@
 export { default as areSameSegment } from './areSameSegment';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';