@cornerstonejs/tools 1.51.5 → 1.53.0

package/src/tools/annotation/splines/Spline.ts

@@ -26,6 +26,7 @@ type CurveSegmentDistanceSquared = {
 abstract class Spline implements ISpline {
   private _controlPoints: Types.Point2[] = [];
   private _resolution: number;
+  private _fixedResolution: boolean;
   private _closed: boolean;
   private _invalidated = false;
   private _curveSegments: SplineCurveSegment[];
@@ -35,6 +36,7 @@ abstract class Spline implements ISpline {
   constructor(props?: SplineProps) {
     this._controlPoints = [];
     this._resolution = props?.resolution ?? 20;
+    this._fixedResolution = props?.fixedResolution ?? false;
     this._closed = props?.closed ?? false;
     this._invalidated = true;
   }
@@ -61,7 +63,7 @@ abstract class Spline implements ISpline {
 
   /** Set the resolution of the spline curve */
   public set resolution(resolution: number) {
-    if (this._resolution === resolution) {
+    if (this._fixedResolution || this._resolution === resolution) {
       return;
     }
 
@@ -69,6 +71,16 @@ abstract class Spline implements ISpline {
     this.invalidated = true;
   }
 
+  /** Fixed resolution
+   *
+   * Linar spline is one of the splines that does not allow changing the resolution
+   * for better performance otherwise it would calculate and render 20 line segments
+   * instead of a single one..
+   */
+  public get fixedResolution() {
+    return this._fixedResolution;
+  }
+
   /** Flag that is set to true when the curve is already closed */
   public get closed(): boolean {
     return this._closed;

package/src/tools/base/AnnotationTool.ts

@@ -19,6 +19,7 @@ import {
   InteractionTypes,
   ToolProps,
   PublicToolProps,
+  IToolBinding,
 } from '../../types';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 

package/src/tools/base/ContourBaseTool.ts

@@ -3,6 +3,7 @@ import type { Types } from '@cornerstonejs/core';
 import {
   addAnnotation,
   getAnnotations,
+  getChildAnnotations,
 } from '../../stateManagement/annotation/annotationState';
 import type {
   Annotation,
@@ -13,9 +14,10 @@ import type {
   SVGDrawingHelper,
   AnnotationRenderContext,
 } from '../../types';
-import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
+import { drawPath as drawPathSvg } from '../../drawingSvg';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import AnnotationTool from './AnnotationTool';
+import { getContourHolesDataCanvas } from '../../utilities/contours';
 
 /**
  * A contour base class responsible for rendering contour instances such as
@@ -177,6 +179,37 @@ abstract class ContourBaseTool extends AnnotationTool {
     // noop method just to give a chance for child classes to override it
   }
 
+  /**
+   * Move an annotation and all its child annotations in a recursive way.
+   *
+   * That is useful when clicking on a spline contour to completely translate
+   * it to a different place. In that case all holes (child annotations) must
+   * also be translated too.
+   *
+   * @param annotation - Annotation
+   * @param worldPosDelta - Delta in world space
+   */
+  protected moveAnnotation(
+    annotation: Annotation,
+    worldPosDelta: Types.Point3
+  ): void {
+    const { points } = annotation.data.handles;
+
+    for (let i = 0, numPoints = points.length; i < numPoints; i++) {
+      const point = points[i];
+
+      point[0] += worldPosDelta[0];
+      point[1] += worldPosDelta[1];
+      point[2] += worldPosDelta[2];
+    }
+
+    annotation.invalidated = true;
+
+    getChildAnnotations(annotation).forEach((childAnnotation) =>
+      this.moveAnnotation(childAnnotation, worldPosDelta)
+    );
+  }
+
   /**
    * Get polyline points in world space.
    * Just to give a chance for child classes to override it.
@@ -197,6 +230,12 @@ abstract class ContourBaseTool extends AnnotationTool {
   ): boolean {
     const { enabledElement, annotationStyle, svgDrawingHelper } = renderContext;
     const annotation = renderContext.annotation as ContourAnnotation;
+
+    // Do not render the contour because it must be rendered by the parent annotation
+    if (annotation.parentAnnotationUID) {
+      return;
+    }
+
     const { annotationUID } = annotation;
     const { viewport } = enabledElement;
     const { worldToCanvas } = viewport;
@@ -206,11 +245,14 @@ abstract class ContourBaseTool extends AnnotationTool {
     const { lineWidth, lineDash, color, fillColor, fillOpacity } =
       annotationStyle;
 
-    drawPolylineSvg(
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [polylineCanvasPoints, ...childContours];
+
+    drawPathSvg(
       svgDrawingHelper,
       annotationUID,
       'contourPolyline',
-      polylineCanvasPoints,
+      allContours,
       {
         color,
         lineDash,

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -175,6 +175,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     const annotation = context.annotation as ContourSegmentationAnnotation;
     const { segmentationRepresentationUID, segmentationId, segmentIndex } =
       annotation.data.segmentation;
+    const segmentation = segmentationState.getSegmentation(segmentationId);
     const segmentationRepresentation =
       segmentationState.getSegmentationRepresentationByUID(
         toolGroupId,
@@ -252,6 +253,11 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
       fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
     }
 
+    // Change the line thickness when the mouse is over the contour segment
+    if (segmentation.activeSegmentIndex === segmentIndex) {
+      lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
+    }
+
     lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
     fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
 

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

@@ -10,6 +10,7 @@ const defaultContourConfig: ContourConfig = {
   outlineDashActive: undefined,
   outlineDashInactive: undefined,
   outlineDashAutoGenerated: '5,3',
+  activeSegmentOutlineWidthDelta: 0,
   renderFill: true,
   fillAlpha: 0.5,
   fillAlphaInactive: 0.3,

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

@@ -1,4 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
 import { ContourAnnotation } from './ContourAnnotation';
+// Import the type so it isn't recursive imports
 
 export type ContourSegmentationAnnotationData = {
   autoGenerated?: boolean;
@@ -8,7 +10,43 @@ export type ContourSegmentationAnnotationData = {
       segmentIndex: number;
       segmentationRepresentationUID: string;
     };
+    contour: {
+      /** The original polyline before livewire, to show comparison with
+       * regenerated data (eg based on spline or livewire changes).
+       */
+      originalPolyline?: Types.Point3[];
+    };
+  };
+  handles: {
+    /**
+     * Segmentation contours can be interpolated between slices to produce
+     * intermediate data.  The interpolation sources are source data for
+     * the interpolation corresponding to the handle points.  The object
+     * will have the kIndex assigned so that one can determine relative slice
+     * locations that the handles are in originally.
+     *
+     * This does NOT necessarily correspond to the handles used on the original
+     * source data, but is the set of point uses to interpolate the current handles.
+     * That is, for linear interpolation:
+     * ```
+     *   handles.points[i] = linear(interpolationSources[0].getPoint(i),
+     *              interpolationSources[1].getPoint(i));
+     * ```
+     *
+     * These are sometimes required for things like livewire which need to
+     * update the handle position with a snap to nearest live point or can
+     * be used as an indicator that interpolation has taken place.
+     */
+    interpolationSources?: Types.PointsManager<Types.Point3>[];
   };
+
+  /**
+   * This is called when interpolation is performed, and can be used to add
+   * data specific settings to the annotation instance.
+   */
+  onInterpolationComplete?: (
+    annotation: ContourSegmentationAnnotation
+  ) => unknown;
 };
 
 export type ContourSegmentationAnnotation = ContourAnnotation &

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

@@ -14,6 +14,8 @@ export type InterpolationViewportData = {
   /** The viewport that this interpolation is occurring within */
   viewport: Types.IViewport;
   sliceData: Types.ImageSliceData;
+  /** True if the interpolation data is being regenerated because of an update */
+  isInterpolationUpdate?: boolean;
 };
 
 export type ImageInterpolationData = {
@@ -39,4 +41,8 @@ export type AcceptInterpolationSelector = {
    * Applies just to the given segment index.
    */
   segmentIndex?: number;
+  /**
+   * Only apply to the given slice index
+   */
+  sliceIndex?: number;
 };

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

@@ -141,11 +141,7 @@ export type SplineROIAnnotation = ContourAnnotation & {
 export type SplineContourSegmentationAnnotation = SplineROIAnnotation &
   ContourSegmentationAnnotationData;
 
-export type LivewireContourAnnotation = ContourAnnotation & {
-  data: {
-    label?: string;
-  };
-};
+export type LivewireContourAnnotation = ContourAnnotation;
 
 export type LivewireContourSegmentationAnnotation = LivewireContourAnnotation &
   ContourSegmentationAnnotationData;
@@ -277,6 +273,12 @@ export type InterpolationROIAnnotation = ContourAnnotation & {
     referencedSliceIndex?: number;
   };
   interpolationUID?: string;
+  /**
+   * A flag to track updates to annotations caused by things like
+   * spline or livewire regeenration of the data, and which should cause further
+   * updates to occur (or not as the tool decides).
+   */
+  isInterpolationUpdate?: boolean;
 };
 
 export interface ArrowAnnotation extends Annotation {

package/src/utilities/contours/getContourHolesDataCanvas.ts

@@ -0,0 +1,33 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+
+/**
+ * Get the polylines for the child annotations (holes)
+ * @param annotation - Annotation
+ * @param viewport - Viewport used to convert the points from world to canvas space
+ * @returns An array that contains all child polylines
+ */
+export default function getContourHolesDataCanvas(
+  annotation: Annotation,
+  viewport: Types.IViewport
+): Types.Point2[][] {
+  const worldHoleContours = getContourHolesDataWorld(annotation);
+  const canvasHoleContours = [];
+
+  worldHoleContours.forEach((worldHoleContour) => {
+    const numPoints = worldHoleContour.length;
+
+    // Pre-allocated arrays are 3-4x faster than multiple "push()" calls
+    const canvasHoleContour: Types.Point2[] = new Array(numPoints);
+
+    // Using FOR loop instead of map() for better performance when processing large arrays
+    for (let i = 0; i < numPoints; i++) {
+      canvasHoleContour[i] = viewport.worldToCanvas(worldHoleContour[i]);
+    }
+
+    canvasHoleContours.push(canvasHoleContour);
+  });
+
+  return canvasHoleContours;
+}

package/src/utilities/contours/getContourHolesDataWorld.ts

@@ -0,0 +1,19 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation, ContourAnnotation } from '../../types';
+import { getAnnotation } from '../../stateManagement';
+
+/**
+ * Get child polylines data in world space for contour annotations that represent the holes
+ * @param annotation - Annotation
+ * @param viewport - Viewport used to convert the points from world to canvas space
+ * @returns An array that contains all child polylines (holes) in world space
+ */
+export default function getContourHolesDataWorld(
+  annotation: Annotation
+): Types.Point3[][] {
+  const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
+
+  return childAnnotationUIDs.map(
+    (uid) => (getAnnotation(uid) as ContourAnnotation).data.contour.polyline
+  );
+}

package/src/utilities/contours/index.ts

@@ -4,6 +4,9 @@ import mergePoints from './mergePoints';
 import detectContourHoles from './detectContourHoles';
 import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
 import AnnotationToPointData from './AnnotationToPointData';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
@@ -15,6 +18,9 @@ export {
   detectContourHoles,
   generateContourSetsFromLabelmap,
   AnnotationToPointData,
+  getContourHolesDataWorld,
+  getContourHolesDataCanvas,
+  updateContourPolyline,
   interpolation,
   acceptAutogeneratedInterpolations,
   findHandlePolylineIndex,

package/src/utilities/contours/interpolation/acceptAutogeneratedInterpolations.ts

@@ -1,3 +1,5 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+
 import InterpolationManager from '../../segmentation/InterpolationManager/InterpolationManager';
 import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
 import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
@@ -5,7 +7,7 @@ import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector
 /**
  * Accepts interpolated annotations, marking them as autoGenerated false.
  *
- * @param annotationGroupSelector - viewport or FOR to select annotations for
+ * @param annotationGroupSelector - viewport or FOR to select annotations on
  * @param selector - nested selection criteria
  */
 export default function acceptAutogeneratedInterpolations(

package/src/utilities/contours/interpolation/createPolylineToolData.ts

@@ -33,7 +33,13 @@ export default function createPolylineToolData(
   });
   Object.assign(annotation.data, {
     handles: {
-      points: handlePoints || [],
+      points: handlePoints.points || handlePoints || [],
+      /**
+       * The interpolation sources contains the source points used for interpolating
+       * to generate the new handles.  This allows performing other types of
+       * interpolation to generate the new handles, such as livewire.
+       */
+      interpolationSources: handlePoints.sources,
       activeHandleIndex: null,
       textBox: {
         hasMoved: false,

package/src/utilities/contours/interpolation/findAnnotationForInterpolation.ts

@@ -129,7 +129,8 @@ function _sliceNeedsInterpolating(
 ): boolean {
   const annotations = interpolationData.get(sliceIndex);
   return (
-    !annotations || (annotations.length === 1 && annotations[0].autoGenerated)
+    !annotations?.length ||
+    (annotations.length === 1 && annotations[0].autoGenerated)
   );
 }
 

package/src/utilities/contours/interpolation/getInterpolationData.ts

@@ -68,7 +68,9 @@ export default function getInterpolationData(
       }
     );
 
-    interpolationDatas.set(i, filteredInterpolatedAnnotations);
+    if (filteredInterpolatedAnnotations.length) {
+      interpolationDatas.set(i, filteredInterpolatedAnnotations);
+    }
   }
 
   return interpolationDatas;