@cornerstonejs/tools 1.51.4 → 1.52.0

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

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

@@ -1,4 +1,4 @@
-import { triggerEvent } from '@cornerstonejs/core';
+import { triggerEvent, utilities } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 
@@ -9,13 +9,20 @@ import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnno
 import type { AnnotationInterpolationCompletedEventDetail } from '../../../types/EventTypes';
 import EventTypes from '../../../enums/Events';
 import * as annotationState from '../../../stateManagement/annotation';
-import { PointsArray } from '../PointsArray';
+import selectHandles from './selectHandles';
+
+const { PointsManager } = utilities;
 
 /**
  * An XYZ encoded points that also includes an indicator I for whether the
  * point is included in the original contour.
  */
-type PointsXYZI = Types.PointsXYZ & {
+export type PointsXYZI = Types.PointsXYZ & {
+  I?: boolean[];
+  kIndex?: number;
+};
+
+export type PointsArray3 = Types.PointsManager<Types.Point3> & {
   I?: boolean[];
 };
 
@@ -25,7 +32,13 @@ let interpolating = false;
 
 /**
  * interpolate - Interpolate missing contours in the ROIContours.
- * If input is tool data collection, it is expected to be sorted in the order of stack image in which it was drawn
+ * If input is tool data collection, it is expected to be sorted in the order
+ * of stack image in which it was drawn.
+ *
+ * This is performed in a microtask in order to avoid delaying the event handler
+ * excessively, but to ensure it is completed before the data is additionally
+ * changed.  It was originally done in a setTimeout, but that allowed the data
+ * to be updated between calls, causing issues with the interpolation process.
  *
  * @param viewportData - Object
  * @returns null
@@ -35,11 +48,24 @@ function interpolate(viewportData: InterpolationViewportData) {
     return;
   }
   interpolating = true;
-  try {
-    startInterpolation(viewportData);
-  } finally {
-    interpolating = false;
-  }
+  const { isInterpolationUpdate, annotation } = viewportData;
+  queueMicrotask(() => {
+    try {
+      if (isInterpolationUpdate) {
+        annotation.isInterpolationUpdate = true;
+        // This may not be true long term, but treat it as user generated for
+        // this run.
+        annotation.autoGenerated = false;
+      }
+      startInterpolation(viewportData);
+    } finally {
+      interpolating = false;
+      if (isInterpolationUpdate) {
+        // Reset the auto generated flag
+        annotation.autoGenerated = true;
+      }
+    }
+  });
 }
 
 /**
@@ -111,6 +137,8 @@ function _linearlyInterpolateBetween(
   );
 
   const { c1Interp, c2Interp } = _generateInterpolationContourPair(c1, c2);
+  c1Interp.kIndex = annotationPair[0];
+  c2Interp.kIndex = annotationPair[1];
 
   // Using the newly constructed contours, interpolate each ROI.
   indices.forEach(function (index) {
@@ -126,6 +154,16 @@ function _linearlyInterpolateBetween(
   });
 }
 
+function getPointCount(pointArray) {
+  let sum = 0;
+  for (let i = 0; i < pointArray.I.length; i++) {
+    if (pointArray.I[i]) {
+      sum++;
+    }
+  }
+  return sum;
+}
+
 /**
  * _linearlyInterpolateContour - Inserts a linearly interpolated contour at
  * specified slice index.
@@ -133,7 +171,7 @@ function _linearlyInterpolateBetween(
  * @param c1Interp - object, The first reference contour.
  * @param c2Interp - object,  The second reference contour.
  * @param sliceIndex - Number, The slice index to interpolate.
- * @param annotationPair - Number[], The slice indicies of the reference contours.
+ * @param annotationPair - Number[], The slice indices of the reference contours.
  * @param interpolationData - object[], Data for the slice location of contours
  *                                  for the ROIContour.
  * @param c1HasMoreNodes - boolean, True if c1 has more nodes than c2.
@@ -162,17 +200,7 @@ function _linearlyInterpolateContour(
     annotationPair[zInterp > 0.5 ? 1 : 0]
   )[0];
 
-  // A bit adhoc figuring out how many handles to use, but this seems to generate
-  // enough handles for use.
-  const handleCount = Math.round(
-    Math.max(
-      8,
-      interpolationData.get(startIndex)[0].data.handles.points.length,
-      interpolationData.get(endIndex)[0].data.handles.points.length,
-      interpolated3DPoints.x.length / 50
-    )
-  );
-  const handlePoints = _subselect(interpolated3DPoints, handleCount);
+  const handlePoints = selectHandles(interpolated3DPoints);
 
   if (interpolationData.has(sliceIndex)) {
     _editInterpolatedContour(
@@ -193,25 +221,6 @@ function _linearlyInterpolateContour(
   }
 }
 
-function _subselect(points, count = 10) {
-  const handles = [];
-  const { length } = points.x;
-  if (!length) {
-    return handles;
-  }
-  for (let i = 0; i < count; i++) {
-    const handleIndex = Math.floor((length * i) / count);
-    handles.push(
-      vec3.fromValues(
-        points.x[handleIndex],
-        points.y[handleIndex],
-        points.z[handleIndex]
-      )
-    );
-  }
-  return handles;
-}
-
 /**
  * _addInterpolatedContour - Adds a new contour to the imageId.
  *
@@ -223,13 +232,13 @@ function _subselect(points, count = 10) {
  * @returns null
  */
 function _addInterpolatedContour(
-  interpolated3DPoints: Types.PointsXYZ,
-  handlePoints: Types.Point3[],
+  interpolated3DPoints: PointsArray3,
+  handlePoints: PointsArray3,
   sliceIndex: number,
   referencedToolData,
   eventData
 ) {
-  const points = PointsArray.fromXYZ(interpolated3DPoints).points;
+  const points = interpolated3DPoints.points;
   const { viewport } = eventData;
 
   const interpolatedAnnotation = createPolylineToolData(
@@ -242,7 +251,7 @@ function _addInterpolatedContour(
   interpolatedAnnotation.metadata.referencedImageId = targetId;
   interpolatedAnnotation.metadata.referencedSliceIndex = sliceIndex;
   annotationState.state.addAnnotation(interpolatedAnnotation, viewport.element);
-  referencedToolData.postInterpolateAction?.(
+  referencedToolData.onInterpolationComplete?.(
     interpolatedAnnotation,
     referencedToolData
   );
@@ -260,8 +269,8 @@ function _addInterpolatedContour(
  * @returns null
  */
 function _editInterpolatedContour(
-  interpolated3DPoints: Types.PointsXYZ,
-  handlePoints: Types.Point3[],
+  interpolated3DPoints: PointsArray3,
+  handlePoints: PointsArray3,
   sliceIndex,
   referencedToolData,
   eventData
@@ -296,7 +305,7 @@ function _editInterpolatedContour(
   }
 
   const oldToolData = annotations[toolDataIndex] as InterpolationROIAnnotation;
-  const points = PointsArray.fromXYZ(interpolated3DPoints).points;
+  const points = interpolated3DPoints.points;
   const interpolatedAnnotation = createPolylineToolData(
     points,
     handlePoints,
@@ -327,22 +336,39 @@ function _generateInterpolatedOpenContour(
   c2ir,
   zInterp,
   c1HasMoreNodes
-): PointsXYZI {
-  const cInterp = {
-    x: [],
-    y: [],
-    z: [],
-  };
-
+): PointsArray3 {
   const indices = c1HasMoreNodes ? c1ir.I : c2ir.I;
 
+  const c1 = PointsManager.fromXYZ(c1ir);
+  const c2 = PointsManager.fromXYZ(c2ir);
+  const { length } = c1;
+  const cInterp = PointsManager.create3(length) as PointsArray3;
+
+  const vecSubtract = vec3.create();
+  const vecResult = vec3.create();
+  const c1Source = PointsManager.create3(length);
+  c1Source.kIndex = c1ir.kIndex;
+  const c2Source = PointsManager.create3(length);
+  c2Source.kIndex = c2ir.kIndex;
+
   for (let i = 0; i < c1ir.x.length; i++) {
     if (indices[i]) {
-      cInterp.x.push(c1ir.x[i] + (c2ir.x[i] - c1ir.x[i]) * zInterp);
-      cInterp.y.push(c1ir.y[i] + (c2ir.y[i] - c1ir.y[i]) * zInterp);
-      cInterp.z.push(c1ir.z[i] + (c2ir.z[i] - c1ir.z[i]) * zInterp);
+      const c1point = c1.getPoint(i);
+      const c2point = c2.getPoint(i);
+      c1Source.push(c1point);
+      c2Source.push(c2point);
+      vec3.sub(vecSubtract, c2point, c1point);
+      cInterp.push(
+        vec3.scaleAndAdd(
+          vecResult,
+          c1point,
+          vecSubtract,
+          zInterp
+        ) as Types.Point3
+      );
     }
   }
+  cInterp.sources = [c1Source, c2Source];
 
   return cInterp;
 }
@@ -370,12 +396,12 @@ function _generateInterpolationContourPair(c1, c2) {
   const numNodes1 = interpNodes + c2.x.length;
   const numNodes2 = interpNodes + c1.x.length;
 
-  // concatinate p && cumPerimNorm
+  // concatenate p && cumPerimNorm
   const perim1Interp = _getInterpolatedPerim(numNodes1, cumPerim1Norm);
   const perim2Interp = _getInterpolatedPerim(numNodes2, cumPerim2Norm);
 
-  const perim1Ind = _getIndicatorArray(c1, numNodes1);
-  const perim2Ind = _getIndicatorArray(c2, numNodes2);
+  const perim1Ind = _getIndicatorArray(numNodes1 - 2, c1.x.length);
+  const perim2Ind = _getIndicatorArray(numNodes2 - 2, c2.x.length);
 
   const nodesPerSegment1 = _getNodesPerSegment(perim1Interp, perim1Ind);
   const nodesPerSegment2 = _getNodesPerSegment(perim2Interp, perim2Ind);
@@ -398,13 +424,13 @@ function _generateInterpolationContourPair(c1, c2) {
  * @returns  An object containing the two reduced contours.
  */
 function _reduceContoursToOriginNodes(c1i: PointsXYZI, c2i: PointsXYZI) {
-  const c1Interp = {
+  const c1Interp: PointsXYZI = {
     x: [],
     y: [],
     z: [],
     I: [],
   };
-  const c2Interp = {
+  const c2Interp: PointsXYZI = {
     x: [],
     y: [],
     z: [],
@@ -505,7 +531,7 @@ function _shiftCircularArray(arr, count) {
  *                                    per line segment.
  * @returns object, The super sampled contour.
  */
-function _getSuperSampledContour(c, nodesPerSegment) {
+function _getSuperSampledContour(c, nodesPerSegment): PointsXYZI {
   const ci = {
     x: [],
     y: [],
@@ -593,17 +619,10 @@ function _getNodesPerSegment(perimInterp, perimInd) {
  * @param numNodes - Number, The number of nodes added.
  * @returns boolean[], The indicator array of original node locations.
  */
-function _getIndicatorArray(contour, numNodes) {
-  const perimInd = [];
-
-  for (let i = 0; i < numNodes - 2; i++) {
-    perimInd.push(false);
-  }
-
-  for (let i = 0; i < contour.x.length; i++) {
-    perimInd.push(true);
-  }
-
+function _getIndicatorArray(numFalse, numTrue) {
+  const perimInd = new Array(numFalse + numTrue);
+  perimInd.fill(false, 0, numFalse);
+  perimInd.fill(true, numFalse, numFalse + numTrue);
   return perimInd;
 }
 
@@ -619,7 +638,7 @@ function _getInterpolatedPerim(numNodes, cumPerimNorm) {
   const diff = 1 / (numNodes - 1);
   const linspace = [diff];
 
-  // Length - 2 as we are discarding 0 an 1 for efficiency (no need to calculate them).
+  // Length - 2 as we are discarding 0 and 1 for efficiency (no need to calculate them).
   for (let i = 1; i < numNodes - 2; i++) {
     linspace.push(linspace[linspace.length - 1] + diff);
   }