@cornerstonejs/tools 1.43.7 → 1.44.0

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -0,0 +1,276 @@
+import { utilities } from '@cornerstonejs/core';
+import {
+  Annotation,
+  EventTypes,
+  PublicToolProps,
+  ToolProps,
+} from '../../types';
+import {
+  config as segmentationConfig,
+  state as segmentationState,
+  segmentLocking,
+  segmentIndex as segmentIndexController,
+  activeSegmentation,
+} from '../../stateManagement/segmentation';
+import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import { StyleSpecifier } from '../../types/AnnotationStyle';
+import { SegmentationRepresentations } from '../../enums';
+import ContourBaseTool from './ContourBaseTool';
+
+/**
+ * A base contour segmentation class responsible for rendering, registering
+ * and unregistering contour segmentation annotations.
+ */
+abstract class ContourSegmentationBaseTool extends ContourBaseTool {
+  constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
+    super(toolProps, defaultToolProps);
+  }
+
+  /**
+   * Allow children classes inherit from this one and disable contour segmentation
+   * behavior and children classes shall work like a normal contour instance which
+   * is useful for "hybrid" classes such as splineROI/splineSeg, livewire/livewireSeg,
+   * freehandROI/freehandSeg. When this method returns false:
+   *   - contour segmentation data is not added to new annotations
+   *   - annotations are not registered/unregistered as segmentations
+   *   - annotation style shall not contain any segmentation style
+   * @returns True if it is a contour segmentation class or false otherwise
+   */
+  protected isContourSegmentationTool(): boolean {
+    return true;
+  }
+
+  protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation {
+    const { toolGroupId } = this;
+    const contourAnnotation = super.createAnnotation(evt);
+
+    if (!this.isContourSegmentationTool()) {
+      return contourAnnotation;
+    }
+
+    const activeSegmentationRepresentation =
+      activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+
+    if (!activeSegmentationRepresentation) {
+      throw new Error(
+        'No active segmentation detected, create one before using scissors tool'
+      );
+    }
+
+    const { type: segmentationType } = activeSegmentationRepresentation;
+
+    if (segmentationType !== SegmentationRepresentations.Contour) {
+      throw new Error(`A contour segmentation must be active`);
+    }
+
+    const { segmentationId, segmentationRepresentationUID } =
+      activeSegmentationRepresentation;
+    const segmentIndex =
+      segmentIndexController.getActiveSegmentIndex(segmentationId);
+
+    return <ContourSegmentationAnnotation>utilities.deepMerge(
+      contourAnnotation,
+      {
+        data: {
+          segmentation: {
+            segmentationId,
+            segmentIndex,
+            segmentationRepresentationUID,
+          },
+        },
+      }
+    );
+  }
+
+  protected addAnnotation(
+    annotation: Annotation,
+    element: HTMLDivElement
+  ): string {
+    const annotationUID = super.addAnnotation(annotation, element);
+
+    if (this.isContourSegmentationTool()) {
+      this._registerContourSegmentationAnnotation(
+        annotation as ContourSegmentationAnnotation
+      );
+    }
+
+    return annotationUID;
+  }
+
+  /**
+   * Unregister the segmentation when the annotation is canceled
+   * @param annotation - Contour segmentation annotation
+   */
+  protected cancelAnnotation(annotation: Annotation): void {
+    if (this.isContourSegmentationTool()) {
+      this._unregisterContourSegmentationAnnotation(
+        annotation as ContourSegmentationAnnotation
+      );
+    }
+
+    super.cancelAnnotation(annotation);
+  }
+
+  /**
+   * Get the annotation style that may or may not be merged with segmentation
+   * style so that it can be used by ROI and contour segmentation annotations
+   * when rendered on a canvas or svg layer.
+   *
+   * Segmentation style shall be a combination of four different configurations
+   * from different levels (global, toolGroup, segmentation and segment) and it
+   * shall not be used when isContourSegmentationTool() is overwritten and changed
+   * by a child class to return `false` when that class should work only as an ROI.
+   */
+  protected getAnnotationStyle(context: {
+    annotation: Annotation;
+    styleSpecifier: StyleSpecifier;
+  }) {
+    const annotationStyle = super.getAnnotationStyle(context);
+
+    if (!this.isContourSegmentationTool()) {
+      return annotationStyle;
+    }
+
+    const contourSegmentationStyle = this._getContourSegmentationStyle(context);
+
+    return utilities.deepMerge(annotationStyle, contourSegmentationStyle);
+  }
+
+  /**
+   * Return the annotation style based on global, toolGroup, segmentation
+   * and segment segmentation configurations.
+   */
+  private _getContourSegmentationStyle(context: {
+    annotation: Annotation;
+    styleSpecifier: StyleSpecifier;
+  }): Record<string, any> {
+    const { toolGroupId } = this;
+    const annotation = context.annotation as ContourSegmentationAnnotation;
+    const { segmentationRepresentationUID, segmentationId, segmentIndex } =
+      annotation.data.segmentation;
+    const segmentationRepresentation =
+      segmentationState.getSegmentationRepresentationByUID(
+        toolGroupId,
+        segmentationRepresentationUID
+      );
+
+    const { active } = segmentationRepresentation;
+    const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+    const annotationLocked = segmentsLocked.includes(segmentIndex as never);
+
+    const segmentColor = segmentationConfig.color.getColorForSegmentIndex(
+      toolGroupId,
+      segmentationRepresentationUID,
+      segmentIndex
+    );
+
+    const segmentationVisible =
+      segmentationConfig.visibility.getSegmentationVisibility(
+        toolGroupId,
+        segmentationRepresentationUID
+      );
+
+    const globalConfig = segmentationConfig.getGlobalConfig();
+
+    const toolGroupConfig =
+      segmentationConfig.getToolGroupSpecificConfig(toolGroupId);
+
+    const segmentationRepresentationConfig =
+      segmentationConfig.getSegmentationRepresentationSpecificConfig(
+        toolGroupId,
+        segmentationRepresentationUID
+      );
+
+    const segmentConfig = segmentationConfig.getSegmentSpecificConfig(
+      toolGroupId,
+      segmentationRepresentationUID,
+      segmentIndex
+    );
+
+    const segmentVisible = segmentationConfig.visibility.getSegmentVisibility(
+      toolGroupId,
+      segmentationRepresentationUID,
+      segmentIndex
+    );
+
+    // Merge the configurations from different levels based on its precedence
+    const mergedConfig = Object.assign(
+      {},
+      globalConfig?.representations?.CONTOUR ?? {},
+      toolGroupConfig?.representations?.CONTOUR ?? {},
+      segmentationRepresentationConfig?.CONTOUR ?? {},
+      segmentConfig?.CONTOUR ?? {}
+    );
+
+    let lineWidth = 1;
+    let lineDash = undefined;
+    let lineOpacity = 1;
+    let fillOpacity = 0;
+
+    if (active) {
+      lineWidth = mergedConfig.outlineWidthActive ?? lineWidth;
+      lineDash = mergedConfig.outlineDashActive ?? lineDash;
+      lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+      fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
+    } else {
+      lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
+      lineDash = mergedConfig.outlineDashInactive ?? lineDash;
+      lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
+      fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
+    }
+
+    lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
+    fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
+
+    const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
+    const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
+
+    return {
+      color,
+      fillColor,
+      lineWidth,
+      fillOpacity,
+      lineDash,
+      textbox: {
+        color,
+      },
+      visibility: segmentationVisible && segmentVisible,
+      locked: annotationLocked,
+    };
+  }
+
+  private _registerContourSegmentationAnnotation(
+    annotation: ContourSegmentationAnnotation
+  ) {
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = segmentationState.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);
+  }
+
+  private _unregisterContourSegmentationAnnotation(
+    annotation: ContourSegmentationAnnotation
+  ) {
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = segmentationState.getSegmentation(segmentationId);
+    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+    const annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+
+    annotationsUIDsSet.delete(annotation.annotationUID);
+
+    // Delete segmentIndex Set if there is no more annotations
+    if (!annotationsUIDsSet.size) {
+      annotationUIDsMap.delete(segmentIndex);
+    }
+  }
+}
+
+export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -79,6 +79,7 @@ async function render(
     console.warn(
       `No contours found for segmentationId ${segmentationId}. Skipping render.`
     );
+    return;
   }
 
   // add the contour sets to the viewport

package/src/tools/index.ts

@@ -27,8 +27,11 @@ import RectangleROITool from './annotation/RectangleROITool';
 import EllipticalROITool from './annotation/EllipticalROITool';
 import CircleROITool from './annotation/CircleROITool';
 import SplineROITool from './annotation/SplineROITool';
+import SplineContourSegmentationTool from './annotation/SplineContourSegmentationTool';
 import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
+import PlanarFreehandContourSegmentationTool from './annotation/PlanarFreehandContourSegmentationTool';
 import LivewireContourTool from './annotation/LivewireContourTool';
+import LivewireContourSegmentationTool from './annotation/LivewireContourSegmentationTool';
 import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
 import AngleTool from './annotation/AngleTool';
 import CobbAngleTool from './annotation/CobbAngleTool';
@@ -79,7 +82,9 @@ export {
   CircleROITool,
   SplineROITool,
   PlanarFreehandROITool,
+  PlanarFreehandContourSegmentationTool,
   LivewireContourTool,
+  LivewireContourSegmentationTool,
   ArrowAnnotateTool,
   AngleTool,
   CobbAngleTool,
@@ -93,6 +98,7 @@ export {
   SphereScissorsTool,
   RectangleROIThresholdTool,
   RectangleROIStartEndThresholdTool,
+  SplineContourSegmentationTool,
   BrushTool,
   MagnifyTool,
   AdvancedMagnifyTool,

package/src/types/ContourAnnotation.ts

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import { Annotation } from './AnnotationTypes';
+
+export type ContourAnnotationData = {
+  data: {
+    contour: {
+      polyline: Types.Point3[];
+      closed: boolean;
+    };
+  };
+};
+
+export type ContourAnnotation = Annotation & ContourAnnotationData;

package/src/types/ContourSegmentationAnnotation.ts

@@ -0,0 +1,14 @@
+import { ContourAnnotation } from './ContourAnnotation';
+
+export type ContourSegmentationAnnotationData = {
+  data: {
+    segmentation: {
+      segmentationId: string;
+      segmentIndex: number;
+      segmentationRepresentationUID: string;
+    };
+  };
+};
+
+export type ContourSegmentationAnnotation = ContourAnnotation &
+  ContourSegmentationAnnotationData;

package/src/types/ContourTypes.ts

@@ -10,6 +10,10 @@ export type ContourConfig = {
   outlineOpacity?: number;
   /** alpha of outline for inactive segmentation */
   outlineOpacityInactive?: number;
+  /** dash style of the outline when segmentation is active */
+  outlineDashActive?: string;
+  /** dash style of the outline when segmentation is inactive */
+  outlineDashInactive?: string;
   /** outline visibility */
   renderOutline?: boolean;
   /** render fill */
@@ -30,5 +34,8 @@ export type ContourRenderingConfig = {
 export type ContourSegmentationData = {
   // Ids of the contourSets that are part of this segmentation
   // in the cache
-  geometryIds: string[];
+  geometryIds?: string[];
+  // Ids of the annotations that are part of this segmentation
+  // grouped by segmentIndex
+  annotationUIDsMap?: Map<number, Set<string>>;
 };

package/src/types/SegmentationStateTypes.ts

@@ -256,7 +256,7 @@ export type SegmentationPublicInput = {
   segmentationId: string;
   representation: {
     type: Enums.SegmentationRepresentations;
-    data:
+    data?:
       | LabelmapSegmentationData
       | ContourSegmentationData
       | SurfaceSegmentationData;

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -1,7 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
 import { Annotation } from './AnnotationTypes';
 import { ISpline } from './';
-import { LivewirePath } from '../utilities/livewire/LiveWirePath';
+import { ContourSegmentationAnnotationData } from './ContourSegmentationAnnotation';
+import { ContourAnnotation } from './ContourAnnotation';
 
 interface ROICachedStats {
   [targetId: string]: {
@@ -119,29 +120,13 @@ export interface CircleROIAnnotation extends Annotation {
   };
 }
 
-export interface SplineROIAnnotation extends Annotation {
+export type SplineROIAnnotation = ContourAnnotation & {
   data: {
     label?: string;
-    handles: {
-      points: Types.Point3[];
-      activeHandleIndex: number | null;
-      textBox?: {
-        hasMoved: boolean;
-        worldPosition: Types.Point3;
-        worldBoundingBox: {
-          topLeft: Types.Point3;
-          topRight: Types.Point3;
-          bottomLeft: Types.Point3;
-          bottomRight: Types.Point3;
-        };
-      };
-    };
     spline: {
       type: string;
       instance: ISpline;
       resolution: number;
-      polyline: Types.Point3[];
-      closed: boolean;
     };
     cachedStats?: {
       [targetId: string]: {
@@ -151,18 +136,19 @@ export interface SplineROIAnnotation extends Annotation {
       };
     };
   };
-}
+};
 
-export interface LivewireContourAnnotation extends Annotation {
+export type SplineContourSegmentationAnnotation = SplineROIAnnotation &
+  ContourSegmentationAnnotationData;
+
+export type LivewireContourAnnotation = ContourAnnotation & {
   data: {
-    polyline: Types.Point3[];
     label?: string;
-    handles: {
-      points: Types.Point3[];
-      activeHandleIndex: number | null;
-    };
   };
-}
+};
+
+export type LivewireContourSegmentationAnnotation = LivewireContourAnnotation &
+  ContourSegmentationAnnotationData;
 
 export interface EllipticalROIAnnotation extends Annotation {
   data: {
@@ -264,41 +250,19 @@ export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
   };
 }
 
-export interface PlanarFreehandROIAnnotation extends Annotation {
-  metadata: {
-    cameraPosition?: Types.Point3;
-    cameraFocalPoint?: Types.Point3;
-    viewPlaneNormal?: Types.Point3;
-    viewUp?: Types.Point3;
-    annotationUID?: string;
-    FrameOfReferenceUID: string;
-    referencedImageId?: string;
-    toolName: string;
-  };
+export type PlanarFreehandROIAnnotation = ContourAnnotation & {
   data: {
-    polyline: Types.Point3[];
     label?: string;
     isOpenContour?: boolean;
     isOpenUShapeContour?: boolean;
     // Present if isOpenUShapeContour is true:
     openUShapeContourVectorToPeak?: Types.Point3[];
-    handles: {
-      points: Types.Point3[];
-      activeHandleIndex: number | null;
-      textBox: {
-        hasMoved: boolean;
-        worldPosition: Types.Point3;
-        worldBoundingBox: {
-          topLeft: Types.Point3;
-          topRight: Types.Point3;
-          bottomLeft: Types.Point3;
-          bottomRight: Types.Point3;
-        };
-      };
-    };
     cachedStats?: ROICachedStats;
   };
-}
+};
+
+export type PlanarFreehandContourSegmentationAnnotation =
+  PlanarFreehandROIAnnotation & ContourSegmentationAnnotationData;
 
 export interface ArrowAnnotation extends Annotation {
   data: {

package/src/types/index.ts

@@ -4,6 +4,14 @@ import type {
   AnnotationState,
   GroupSpecificAnnotations,
 } from './AnnotationTypes';
+import type {
+  ContourAnnotationData,
+  ContourAnnotation,
+} from './ContourAnnotation';
+import type {
+  ContourSegmentationAnnotationData,
+  ContourSegmentationAnnotation,
+} from './ContourSegmentationAnnotation';
 import type * as EventTypes from './EventTypes';
 import type * as LabelmapTypes from './LabelmapTypes';
 import type IPoints from './IPoints';
@@ -79,6 +87,10 @@ export type {
   // AnnotationState
   Annotation,
   Annotations,
+  ContourAnnotationData,
+  ContourAnnotation,
+  ContourSegmentationAnnotationData,
+  ContourSegmentationAnnotation,
   BidirectionalData,
   CanvasCoordinates,
   IAnnotationManager,