@cornerstonejs/tools 1.52.0 → 1.54.0

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

@@ -3,6 +3,20 @@ import type { Types } from '@cornerstonejs/core';
 type Annotation = {
   /** A unique identifier for this annotation */
   annotationUID?: string;
+  /**
+   * Parent annotation UID
+   *
+   * An annotation may have a parent annotation when it is, for example, a
+   * hole inside a contour.
+   */
+  parentAnnotationUID?: string;
+  /**
+   * Array that contains all child annotation UID
+   *
+   * An annotation may have one or more child annotations when it is contour
+   * and have some holes in it.
+   */
+  childAnnotationUIDs?: string[];
   /** If the annotation is being hovered over and is highlighted */
   highlighted?: boolean;
   /** If the annotation is locked for manipulation */

package/src/types/ContourAnnotation.ts

@@ -1,11 +1,24 @@
 import type { Types } from '@cornerstonejs/core';
 import { Annotation } from './AnnotationTypes';
 
+/**
+ * Polyline winding direction
+ *
+ * It is defined as -1 and 1 to make it easier to change its direction multiplying
+ * by -1 whenever polyline.reverse() is called instead of using IF/ELSE
+ */
+export enum ContourWindingDirection {
+  CounterClockwise = -1,
+  Unknown = 0,
+  Clockwise = 1,
+}
+
 export type ContourAnnotationData = {
   data: {
     contour: {
       polyline: Types.Point3[];
       closed: boolean;
+      windingDirection?: ContourWindingDirection;
     };
   };
 };

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

@@ -16,6 +16,9 @@ export type ContourConfig = {
   outlineDashActive?: string;
   /** dash style of the outline when segmentation is inactive */
   outlineDashInactive?: string;
+  /** delta thickness of the active segment index outline (0 means same thickness,
+   * 1 means 1px thicker, -1 means 1px thinner) */
+  activeSegmentOutlineWidthDelta?: number;
   /**
    * Dash style of the outline when segmentation is auto-generated
    */

package/src/types/EventTypes.ts

@@ -214,6 +214,14 @@ type AnnotationInterpolationRemovedEventDetail = {
   renderingEngineId: string;
 };
 
+/**
+ * The data that is passed to the event handler when a new contour annotation is
+ * completed drawing on the viewport.
+ */
+type ContourAnnotationCompletedEventDetail = AnnotationCompletedEventDetail & {
+  contourHoleProcessingEnabled: boolean;
+};
+
 /**
  * EventDetail for when a Segmentation Data is modified by a tool
  */
@@ -713,6 +721,7 @@ export {
   AnnotationInterpolationCompletedEventType,
   AnnotationInterpolationRemovedEventDetail,
   AnnotationInterpolationRemovedEventType,
+  ContourAnnotationCompletedEventDetail,
   SegmentationDataModifiedEventType,
   SegmentationRepresentationModifiedEventDetail,
   SegmentationRepresentationModifiedEventType,

package/src/types/ISpline.ts

@@ -19,6 +19,9 @@ export interface ISpline {
   /** Set the resolution of the spline curve */
   set resolution(resolution: number);
 
+  /** Fixed resolution (eg: Linear Spline) */
+  get fixedResolution(): boolean;
+
   /** Flag that is set to true when the curve is already closed */
   get closed(): boolean;
 

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

@@ -10,6 +10,16 @@ export type SplineProps = {
    */
   resolution?: number;
 
+  /**
+   * Fixed resolution (Linear spline)
+   *
+   * Splines with `fixedResolution` set to true shall attempt to change the
+   * resolution (eg: spline.resolution = 10). That is useful, for example, for
+   * linear splines because having more line segments between two control points
+   * would not change its resolution and that is why it is fixed to 0.
+   */
+  fixedResolution?: boolean;
+
   /** Flag that is set to true when the curve is closed */
   closed?: boolean;
 };

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);