@cornerstonejs/tools 1.63.5 → 1.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.63.5",
+  "version": "1.64.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.63.5",
+    "@cornerstonejs/core": "^1.64.0",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
@@ -59,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "e2d969d1bf43e204ce5bed804ca3af01d2071a08"
+  "gitHead": "997836e0c4aa342a1af3bc436a6c06112b24cfbc"
 }

package/src/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.ts

@@ -201,7 +201,12 @@ function findIntersectingContour(
   }
 }
 
-function createPolylineHole(
+/**
+ * Modifies the holeAnnotation to work as a contour hole in the targetAnnotation,
+ * displayed on the given viewport.
+
+ */
+export function createPolylineHole(
   viewport: Types.IViewport,
   targetAnnotation: ContourSegmentationAnnotation,
   holeAnnotation: ContourSegmentationAnnotation

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -30,6 +30,8 @@ import { initElementCursor } from '../../cursors/elementCursor';
 
 const { Active, Passive, Enabled, Disabled } = ToolModes;
 
+const PRIMARY_BINDINGS = [{ mouseButton: MouseBindings.Primary }];
+
 /**
  * ToolGroup class which is a container for tools and their modes and states.
  * In Cornerstone3DTools, you need to create a tool group in order to use the
@@ -424,7 +426,7 @@ export default class ToolGroup implements IToolGroup {
    */
   public setToolPassive(
     toolName: string,
-    options?: { removeAllBindings?: boolean }
+    options?: { removeAllBindings?: boolean | IToolBinding[] }
   ): void {
     const toolInstance = this._toolInstances[toolName];
 
@@ -449,13 +451,18 @@ export default class ToolGroup implements IToolGroup {
       }
     );
 
-    const defaultMousePrimary = this.getDefaultMousePrimary();
+    const matchBindings = Array.isArray(options?.removeAllBindings)
+      ? options.removeAllBindings
+      : this.getDefaultPrimaryBindings();
 
     // Remove the primary button bindings without modifiers, if they exist
     toolOptions.bindings = toolOptions.bindings.filter(
       (binding) =>
         options?.removeAllBindings !== true &&
-        (binding.mouseButton !== defaultMousePrimary || binding.modifierKey)
+        !matchBindings.some((matchBinding) =>
+          hasSameBinding(binding, matchBinding)
+        )
+      //(binding.mouseButton !== defaultMousePrimary || binding.modifierKey)
     );
     // If there are other bindings, set the tool to be active
     let mode = Passive;
@@ -681,12 +688,20 @@ export default class ToolGroup implements IToolGroup {
 
   /**
    * Returns the default mouse primary button.
-   *
    */
   public getDefaultMousePrimary(): MouseBindings {
     return MouseBindings.Primary;
   }
 
+  /**
+   * Gets an array of bindings that is the full primary binding.
+   * Currently this is just the primary mouse button, but may be extended in the
+   * future to include touch or other binding types.
+   */
+  public getDefaultPrimaryBindings(): IToolBinding[] {
+    return PRIMARY_BINDINGS;
+  }
+
   /**
    * Get the configuration of tool. It returns only the config for the given path (in case exists).
    * ConfigurationPath is the the path of the property to get separated by '.'.
@@ -759,12 +774,9 @@ export default class ToolGroup implements IToolGroup {
    * @returns A boolean value.
    */
   private _hasMousePrimaryButtonBinding(toolOptions) {
-    const defaultMousePrimary = this.getDefaultMousePrimary();
-
-    return toolOptions?.bindings?.some(
-      (binding) =>
-        binding.mouseButton === defaultMousePrimary &&
-        binding.modifierKey === undefined
+    const primaryBindings = this.getDefaultPrimaryBindings();
+    return toolOptions?.bindings?.some((binding) =>
+      primaryBindings.some((primary) => hasSameBinding(binding, primary))
     );
   }
 
@@ -799,6 +811,9 @@ export default class ToolGroup implements IToolGroup {
   }
 }
 
+/**
+ * Figure out if the two bindings are the same
+ */
 function hasSameBinding(
   binding1: IToolBinding,
   binding2: IToolBinding
@@ -806,6 +821,9 @@ function hasSameBinding(
   if (binding1.mouseButton !== binding2.mouseButton) {
     return false;
   }
+  if (binding1.numTouchPoints !== binding2.numTouchPoints) {
+    return false;
+  }
 
   return binding1.modifierKey === binding2.modifierKey;
 }

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -372,7 +372,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
 
-    const points = annotation.data.contour.polyline;
+    const { polyline: points } = annotation.data.contour;
 
     // NOTE: It is implemented this way so that we do not double calculate
     // points when number crunching adjacent line segments.
@@ -402,7 +402,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     return pointCanProjectOnLine(canvasCoords, pStart, pEnd, proximity);
   };
 
-  cancel = (element: HTMLDivElement): void => {
+  public cancel = (element: HTMLDivElement): void => {
     const isDrawing = this.isDrawing;
     const isEditingOpen = this.isEditingOpen;
     const isEditingClosed = this.isEditingClosed;
@@ -421,7 +421,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
    * `handles`, which means `filterAnnotationsForDisplay` fails inside
    * `filterAnnotationsWithinSlice`.
    */
-  filterInteractableAnnotationsForElement(
+  public filterInteractableAnnotationsForElement(
     element: HTMLDivElement,
     annotations: Annotations
   ): Annotations | undefined {

package/src/tools/annotation/SplineROITool.ts

@@ -691,12 +691,17 @@ class SplineROITool extends ContourSegmentationBaseTool {
     const splineConfig = this._getSplineConfig(splineType);
     const spline = annotation.data.spline.instance;
 
+    const childAnnotations = getChildAnnotations(annotation);
+    const missingAnnotation = childAnnotations.findIndex((it) => !it);
+    if (missingAnnotation !== -1) {
+      // Child annotations go AWOL for a variety of reasons, so report is specifically here
+      throw new Error(
+        `Can't find annotation for child ${annotation.childAnnotationUIDs.join()}`
+      );
+    }
     // Update current and all child annotations/splines
-    const splineAnnotationsGroup = [
-      annotation,
-      ...getChildAnnotations(annotation),
-    ].filter((annotation) =>
-      this._isSplineROIAnnotation(annotation)
+    const splineAnnotationsGroup = [annotation, ...childAnnotations].filter(
+      (annotation) => this._isSplineROIAnnotation(annotation)
     ) as SplineROIAnnotation[];
 
     splineAnnotationsGroup.forEach((annotation) => {

package/src/tools/annotation/planarFreehandROITool/drawLoop.ts

@@ -18,7 +18,7 @@ import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotati
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
-import reverseIfAntiClockwise from '../../../utilities/contours/reverseIfAntiClockwise';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
 
 const {
   addCanvasPointsToArray,
@@ -234,19 +234,16 @@ function completeDrawClosedContour(
   // Remove last point which will be a duplicate now.
   canvasPoints.pop();
 
-  const clockwise = this.configuration.makeClockWise
-    ? reverseIfAntiClockwise(canvasPoints)
-    : canvasPoints;
-
   const updatedPoints = shouldSmooth(this.configuration, annotation)
-    ? getInterpolatedPoints(this.configuration, clockwise)
-    : clockwise;
+    ? getInterpolatedPoints(this.configuration, canvasPoints)
+    : canvasPoints;
 
   this.updateContourPolyline(
     annotation,
     {
       points: updatedPoints,
       closed: true,
+      targetWindingDirection: ContourWindingDirection.Clockwise,
     },
     viewport
   );

package/src/types/IToolGroup.ts

@@ -1,9 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
-import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
+import {
+  IToolBinding,
+  SetToolBindingsType,
+  ToolOptionsType,
+} from './ISetToolModeOptions';
 import { MouseBindings } from '../enums';
 import { ToolConfiguration } from '../types';
 /**
  * ToolGroup interface
+ * @deprecated - this is going away in favour of using the type import from the
+ *      tool group itself.
  */
 export default interface IToolGroup {
   /** Unserializable instantiated tool classes, keyed by name */
@@ -44,7 +50,10 @@ export default interface IToolGroup {
   };
   /** Setting the tool to be Passive by its name*/
   setToolPassive: {
-    (toolName: string, options?: { removeAllBindings?: boolean }): void;
+    (
+      toolName: string,
+      options?: { removeAllBindings?: boolean | IToolBinding[] }
+    ): void;
   };
   /** Setting the tool to be Enabled by its name*/
   setToolEnabled: {

package/src/types/index.ts

@@ -23,7 +23,7 @@ import type {
   IToolBinding,
   ToolOptionsType,
 } from './ISetToolModeOptions';
-import type IToolGroup from './IToolGroup';
+import type IToolGroup from '../store/ToolGroupManager/ToolGroup';
 import type * as ToolSpecificAnnotationTypes from './ToolSpecificAnnotationTypes';
 import type * as AnnotationStyle from './AnnotationStyle';
 import type ToolHandle from './ToolHandle';

package/src/utilities/contourSegmentation/addContourSegmentationAnnotation.ts

@@ -8,6 +8,10 @@ import { ContourSegmentationAnnotation } from '../../types';
 export function addContourSegmentationAnnotation(
   annotation: ContourSegmentationAnnotation
 ) {
+  if (annotation.parentAnnotationUID) {
+    // Don't add it for parent annotations - this happens during interpolation
+    return;
+  }
   if (!annotation.data.segmentation) {
     throw new Error(
       'addContourSegmentationAnnotation: annotation does not have a segmentation data'

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

@@ -31,6 +31,7 @@ export default function createPolylineToolData(
     annotationUID: undefined,
     cachedStats: {},
     childAnnotationUIDs: [],
+    parentAnnotationUID: undefined,
   });
   Object.assign(annotation.data, {
     handles: {
@@ -54,8 +55,8 @@ export default function createPolylineToolData(
       },
     },
     contour: {
+      ...referencedToolData.data.contour,
       polyline,
-      closed: true,
     },
   });
 

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

@@ -10,6 +10,8 @@ import type { AnnotationInterpolationCompletedEventDetail } from '../../../types
 import EventTypes from '../../../enums/Events';
 import * as annotationState from '../../../stateManagement/annotation';
 import selectHandles from './selectHandles';
+import updateChildInterpolationUID from './updateChildInterpolationUID';
+import { createPolylineHole } from '../../../eventListeners/annotations/contourSegmentation/contourSegmentationCompleted';
 
 const { PointsManager } = utilities;
 
@@ -70,7 +72,8 @@ function interpolate(viewportData: InterpolationViewportData) {
  * @returns null
  */
 function startInterpolation(viewportData: InterpolationViewportData) {
-  const toolData = viewportData.annotation;
+  const { annotation: toolData } = viewportData;
+  updateChildInterpolationUID(toolData);
   const { interpolationData, interpolationList } =
     findAnnotationsForInterpolation(toolData, viewportData) || {};
 
@@ -129,12 +132,10 @@ function _linearlyInterpolateBetween(
   interpolationData,
   eventData
 ) {
-  const c1 = _generateClosedContour(
-    interpolationData.get(annotationPair[0])[0].data.contour.polyline
-  );
-  const c2 = _generateClosedContour(
-    interpolationData.get(annotationPair[1])[0].data.contour.polyline
-  );
+  const annotation0 = interpolationData.get(annotationPair[0])[0];
+  const annotation1 = interpolationData.get(annotationPair[1])[0];
+  const c1 = _generateClosedContour(annotation0.data.contour.polyline);
+  const c2 = _generateClosedContour(annotation1.data.contour.polyline);
 
   const { c1Interp, c2Interp } = _generateInterpolationContourPair(c1, c2);
   c1Interp.kIndex = annotationPair[0];
@@ -189,6 +190,8 @@ function _linearlyInterpolateContour(
 ) {
   const [startIndex, endIndex] = annotationPair;
   const zInterp = (sliceIndex - startIndex) / (endIndex - startIndex);
+  const annotation0 = interpolationData.get(startIndex)[0];
+  const annotation1 = interpolationData.get(endIndex)[0];
   const interpolated3DPoints = _generateInterpolatedOpenContour(
     c1Interp,
     c2Interp,
@@ -196,9 +199,7 @@ function _linearlyInterpolateContour(
     c1HasMoreNodes
   );
 
-  const nearestAnnotation = interpolationData.get(
-    annotationPair[zInterp > 0.5 ? 1 : 0]
-  )[0];
+  const nearestAnnotation = zInterp > 0.5 ? annotation1 : annotation0;
 
   const handlePoints = selectHandles(interpolated3DPoints);
 
@@ -255,8 +256,41 @@ function _addInterpolatedContour(
     interpolatedAnnotation,
     referencedToolData
   );
+
+  const { parentAnnotationUID } = referencedToolData;
+  if (parentAnnotationUID) {
+    const parentReferenced =
+      annotationState.state.getAnnotation(parentAnnotationUID);
+    const parentAnnotation = _findExistingAnnotation(
+      parentReferenced,
+      sliceIndex,
+      eventData
+    );
+    createPolylineHole(viewport, parentAnnotation, interpolatedAnnotation);
+  }
 }
 
+/**
+ * Finds an existing annotation on the given slide, with the interpolation UID as
+ * specified in the referenced tool data.
+ */
+function _findExistingAnnotation(referencedToolData, sliceIndex, eventData) {
+  const { viewport } = eventData;
+  const annotations = annotationState.state.getAnnotations(
+    referencedToolData.metadata.toolName,
+    viewport.element
+  );
+
+  for (let i = 0; i < annotations.length; i++) {
+    const annotation = annotations[i] as InterpolationROIAnnotation;
+    if (
+      annotation.interpolationUID === referencedToolData.interpolationUID &&
+      annotation.metadata.sliceIndex === sliceIndex
+    ) {
+      return annotation;
+    }
+  }
+}
 /**
  * _editInterpolatedContour - Edits an interpolated polygon on the imageId
  * that corresponds to the specified ROIContour.
@@ -266,7 +300,6 @@ function _addInterpolatedContour(
  * @param referencedToolData - type, The toolData of another polygon in the
  * ROIContour, to assign appropriate metadata to the new polygon.
  * @param eventData - object
- * @returns null
  */
 function _editInterpolatedContour(
   interpolated3DPoints: PointsArray3,
@@ -275,46 +308,23 @@ function _editInterpolatedContour(
   referencedToolData,
   eventData
 ) {
-  const { viewport } = eventData;
-  const annotations = annotationState.state.getAnnotations(
-    referencedToolData.metadata.toolName,
-    viewport.element
+  const oldAnnotationData = _findExistingAnnotation(
+    referencedToolData,
+    sliceIndex,
+    eventData
   );
 
-  // Find the index of the polygon on this slice corresponding to
-  // The ROIContour.
-  let toolDataIndex;
-
-  for (let i = 0; i < annotations.length; i++) {
-    const annotation = annotations[i] as InterpolationROIAnnotation;
-    if (
-      annotation.interpolationUID === referencedToolData.interpolationUID &&
-      annotation.metadata.sliceIndex === sliceIndex
-    ) {
-      toolDataIndex = i;
-      break;
-    }
-  }
-  if (toolDataIndex === undefined) {
-    console.warn(
-      'Unable to find referenced slice index in the tool data',
-      sliceIndex,
-      annotations
-    );
-    return;
-  }
-
-  const oldToolData = annotations[toolDataIndex] as InterpolationROIAnnotation;
   const points = interpolated3DPoints.points;
   const interpolatedAnnotation = createPolylineToolData(
     points,
     handlePoints,
-    oldToolData
+    oldAnnotationData
   );
-  // To update existing annotation, not intend to add or remove
-  interpolatedAnnotation.annotationUID = oldToolData.annotationUID;
-  annotationState.state.removeAnnotation(oldToolData.annotationUID);
-  annotationState.state.addAnnotation(interpolatedAnnotation, viewport.element);
+  // Does a real update here instead of an add/remove, which caused delete issues in child annotations
+  Object.assign(oldAnnotationData, {
+    metadata: interpolatedAnnotation.metadata,
+    data: interpolatedAnnotation.data,
+  });
 }
 
 /**

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

@@ -21,7 +21,7 @@ export default function selectHandles(
   const { sources: destPoints } = handles;
   const { length, sources: sourcePoints = [] } = polyline;
   // The distance used for figuring out the local angle of a line
-  const distance = 6;
+  const distance = 5;
   if (length < distance * 3) {
     return polyline.subselect(handleCount);
   }
@@ -29,8 +29,9 @@ export default function selectHandles(
   // variation between points in terms of the distance of a line angle, but
   // also not too many handles either.
   // On average, we get twice the interval between handles, so double the length here.
+  // Or, choose a longer interval if the handle count would have too many handles (too short an interval)
   const interval = Math.floor(
-    Math.max((2 * length) / handleCount, distance * 5)
+    Math.max((2 * length) / handleCount, distance * 2)
   );
   sourcePoints.forEach(() =>
     destPoints.push(PointsManager.create3(handleCount))

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

@@ -0,0 +1,23 @@
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import * as annotationState from '../../../stateManagement/annotation';
+
+/**
+ * Updates child annotation interpolation UIDs to be the parent interpolationUID
+ * followed by `-{index}` where the index is the hole/child index.  This causes
+ * child annotations to be matched positionally within the parent.
+ */
+export default function updateChildInterpolationUID(
+  annotation: InterpolationROIAnnotation
+) {
+  const { parentAnnotationUID, annotationUID } = annotation;
+  if (!parentAnnotationUID) {
+    return annotation.interpolationUID;
+  }
+  const parentAnnotation = annotationState.state.getAnnotation(
+    parentAnnotationUID
+  ) as InterpolationROIAnnotation;
+  const { interpolationUID } = parentAnnotation;
+  const index = parentAnnotation.childAnnotationUIDs.indexOf(annotationUID);
+  annotation.interpolationUID = `${interpolationUID}-${index}`;
+  return annotation.interpolationUID;
+}

package/src/utilities/segmentation/InterpolationManager/InterpolationManager.ts

@@ -209,7 +209,6 @@ export default class InterpolationManager {
     ) {
       return;
     }
-
     const viewport = getViewportForAnnotation(annotation);
     if (!viewport) {
       console.warn(
@@ -219,7 +218,8 @@ export default class InterpolationManager {
       return;
     }
     if (annotation.autoGenerated) {
-      // Dont fire the annotation changed events here, as that leads to recursion.
+      // Dont fire the annotation changed events here, as that leads to recursion,
+      // although this is in fact completing the event, so trigger the segmentation add
       addContourSegmentationAnnotation(annotation);
       annotation.autoGenerated = false;
     }