@cornerstonejs/tools 1.50.2 → 1.51.0

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -1,9 +1,10 @@
 import { utilities } from '@cornerstonejs/core';
-import {
+import type {
   Annotation,
   EventTypes,
   PublicToolProps,
   ToolProps,
+  AnnotationRenderContext,
 } from '../../types';
 import {
   config as segmentationConfig,
@@ -12,10 +13,12 @@ import {
   segmentIndex as segmentIndexController,
   activeSegmentation,
 } from '../../stateManagement/segmentation';
-import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
-import { StyleSpecifier } from '../../types/AnnotationStyle';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { SplineContourSegmentationAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { StyleSpecifier } from '../../types/AnnotationStyle';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { InterpolationManager } from '../../utilities/contours/interpolation';
 
 /**
@@ -93,9 +96,9 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     const annotationUID = super.addAnnotation(annotation, element);
 
     if (this.isContourSegmentationTool()) {
-      this._registerContourSegmentationAnnotation(
-        annotation as ContourSegmentationAnnotation
-      );
+      const contourSegAnnotation = annotation as ContourSegmentationAnnotation;
+
+      this._registerContourSegmentationAnnotation(contourSegAnnotation);
     }
 
     return annotationUID;
@@ -140,6 +143,26 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     return utilities.deepMerge(annotationStyle, contourSegmentationStyle);
   }
 
+  protected renderAnnotationInstance(
+    renderContext: AnnotationRenderContext
+  ): boolean {
+    const { annotation } = renderContext;
+    const { invalidated } = annotation;
+
+    // Render the annotation before triggering events
+    const renderResult = super.renderAnnotationInstance(renderContext);
+
+    if (invalidated && this.isContourSegmentationTool()) {
+      const { segmentationId } = (<SplineContourSegmentationAnnotation>(
+        annotation
+      )).data.segmentation;
+
+      triggerSegmentationDataModified(segmentationId);
+    }
+
+    return renderResult;
+  }
+
   /**
    * Return the annotation style based on global, toolGroup, segmentation
    * and segment segmentation configurations.

package/src/tools/segmentation/RectangleROIStartEndThresholdTool.ts

@@ -3,23 +3,20 @@ import {
   cache,
   StackViewport,
   metaData,
-  triggerEvent,
-  eventTarget,
   utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { vec3 } from 'gl-matrix';
-import { Events } from '../../enums';
 import { addAnnotation, getAnnotations } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import {
   drawHandles as drawHandlesSvg,
   drawRect as drawRectSvg,
 } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
-import { AnnotationModifiedEventDetail } from '../../types/EventTypes';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
@@ -266,7 +263,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
 
   _calculateCachedStatsTool(annotation, enabledElement) {
     const data = annotation.data;
-    const { viewportId, renderingEngineId, viewport } = enabledElement;
+    const { element, viewport } = enabledElement;
 
     const { cachedStats } = data;
     const targetId = this.getTargetId(viewport);
@@ -280,14 +277,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     annotation.invalidated = false;
 
     // Dispatching annotation modified
-    const eventType = Events.ANNOTATION_MODIFIED;
-
-    const eventDetail: AnnotationModifiedEventDetail = {
-      annotation,
-      viewportId,
-      renderingEngineId,
-    };
-    triggerEvent(eventTarget, eventType, eventDetail);
+    triggerAnnotationModified(annotation, element);
 
     return cachedStats;
   }

package/src/tools/segmentation/RectangleROIThresholdTool.ts

@@ -2,15 +2,12 @@ import {
   getEnabledElement,
   cache,
   StackViewport,
-  triggerEvent,
-  eventTarget,
   utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { addAnnotation, getAnnotations } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { Events } from '../../enums';
 
 import {
   drawHandles as drawHandlesSvg,
@@ -20,6 +17,7 @@ import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters'
 import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import {
   PublicToolProps,
   ToolProps,
@@ -27,7 +25,6 @@ import {
   SVGDrawingHelper,
 } from '../../types';
 import { RectangleROIThresholdAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import { AnnotationModifiedEventDetail } from '../../types/EventTypes';
 import RectangleROITool from '../annotation/RectangleROITool';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 
@@ -172,7 +169,7 @@ class RectangleROIThresholdTool extends RectangleROITool {
     svgDrawingHelper: SVGDrawingHelper
   ): boolean => {
     let renderStatus = false;
-    const { viewport, renderingEngineId } = enabledElement;
+    const { viewport } = enabledElement;
     const { element } = viewport;
     let annotations = getAnnotations(this.getToolName(), element);
 
@@ -216,15 +213,7 @@ class RectangleROIThresholdTool extends RectangleROITool {
       // Todo: This is not correct way to add the event trigger,
       // this will trigger on all mouse hover too. Problem is that we don't
       // have a cached stats mechanism for this tool yet?
-      const eventType = Events.ANNOTATION_MODIFIED;
-
-      const eventDetail: AnnotationModifiedEventDetail = {
-        annotation,
-        viewportId: viewport.id,
-        renderingEngineId,
-      };
-
-      triggerEvent(eventTarget, eventType, eventDetail);
+      triggerAnnotationModified(annotation, element);
 
       let activeHandleCanvasCoords;
 

package/src/types/AnnotationRenderContext.ts

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from './AnnotationTypes';
+import type SVGDrawingHelper from './SVGDrawingHelper';
+
+type AnnotationRenderContext = {
+  enabledElement: Types.IEnabledElement;
+  targetId: string;
+  annotation: Annotation;
+  annotationStyle: Record<string, any>;
+  svgDrawingHelper: SVGDrawingHelper;
+};
+
+export default AnnotationRenderContext;

package/src/types/IToolGroup.ts

@@ -20,6 +20,8 @@ export default interface IToolGroup {
   getViewportsInfo: () => Array<Types.IViewportId>;
   /** Get the toolInstance of the toolName */
   getToolInstance: { (toolName: string): any };
+  /** Check if a tool is already added to the tool group */
+  hasTool(toolName: string): boolean;
   /** Add a tool to toolGroup with its configuration and custom calculator if wanted */
   addTool: {
     (toolName: string, toolConfiguration?: ToolConfiguration): void;
@@ -70,7 +72,7 @@ export default interface IToolGroup {
     ): void;
   };
   getToolConfiguration: {
-    (toolName: string, configurationPath: string): any;
+    (toolName: string, configurationPath?: string): any;
   };
   getDefaultMousePrimary: {
     (): MouseBindings;

package/src/types/index.ts

@@ -63,6 +63,7 @@ import type IToolClassReference from './IToolClassReference';
 import type { ContourSegmentationData } from './ContourTypes';
 import type IAnnotationManager from './IAnnotationManager';
 import type AnnotationGroupSelector from './AnnotationGroupSelector';
+import type AnnotationRenderContext from './AnnotationRenderContext';
 import type { Statistics } from './CalculatorTypes';
 import type { CanvasCoordinates } from '../utilities/math/ellipse/getCanvasEllipseCorners';
 import {
@@ -106,6 +107,8 @@ export type {
   ToolSpecificAnnotationTypes,
   JumpToSliceOptions,
   AnnotationGroupSelector,
+  // Rendering
+  AnnotationRenderContext,
   // Geometry
   PlanarBoundingBox,
   ToolProps,

package/src/utilities/contourSegmentation/areSameSegment.ts

@@ -0,0 +1,24 @@
+import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+
+/**
+ * Check if two contour segmentations are from same segmentId,
+ * segmentationRepresentationUID and segmentIndex.
+ * @param firstAnnotation - First annotation
+ * @param secondAnnotation - Second annotation
+ * @returns True if they are from same segmentId, segmentationRepresentationUID
+ * and segmentIndex or false otherwise.
+ */
+export default function areSameSegment(
+  firstAnnotation: ContourSegmentationAnnotation,
+  secondAnnotation: ContourSegmentationAnnotation
+) {
+  const { segmentation: firstSegmentation } = firstAnnotation.data;
+  const { segmentation: secondSegmentation } = secondAnnotation.data;
+
+  return (
+    firstSegmentation.segmentationId === secondSegmentation.segmentationId &&
+    firstSegmentation.segmentationRepresentationUID ===
+      secondSegmentation.segmentationRepresentationUID &&
+    firstSegmentation.segmentIndex === secondSegmentation.segmentIndex
+  );
+}

package/src/utilities/contourSegmentation/index.ts

@@ -0,0 +1,2 @@
+export { default as areSameSegment } from './areSameSegment';
+export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';

package/src/utilities/contourSegmentation/isContourSegmentationAnnotation.ts

@@ -0,0 +1,8 @@
+import { Annotation } from '../../types';
+import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+
+export default function isContourSegmentationAnnotation(
+  annotation: Annotation
+): annotation is ContourSegmentationAnnotation {
+  return !!(<ContourSegmentationAnnotation>annotation).data?.segmentation;
+}

package/src/utilities/contours/areCoplanarContours.ts

@@ -0,0 +1,39 @@
+import { glMatrix, vec3 } from 'gl-matrix';
+import { ContourAnnotation } from '../../types/ContourAnnotation';
+
+/**
+ * Check if two contour segmentation annotations are coplanar.
+ *
+ * A plane may be represented by a normal and a distance then to know if they
+ * are coplanar we need to:
+ *   - check if the normals of the two annotations are pointing to the same
+ *   direction or to opposite directions (dot product equal to 1 or -1
+ *   respectively)
+ *   - Get one point from each polyline and project it onto the normal to get
+ *   the distance from the origin (0, 0, 0).
+ */
+export default function areCoplanarContours(
+  firstAnnotation: ContourAnnotation,
+  secondAnnotation: ContourAnnotation
+) {
+  const { viewPlaneNormal: firstViewPlaneNormal } = firstAnnotation.metadata;
+  const { viewPlaneNormal: secondViewPlaneNormal } = secondAnnotation.metadata;
+  const dot = vec3.dot(firstViewPlaneNormal, secondViewPlaneNormal);
+  const parallelPlanes = glMatrix.equals(1, Math.abs(dot));
+
+  if (!parallelPlanes) {
+    return false;
+  }
+
+  const { polyline: firstPolyline } = firstAnnotation.data.contour;
+  const { polyline: secondPolyline } = secondAnnotation.data.contour;
+
+  // Choose one of the normals and calculate the distance of a point from each
+  // polyline along that normal. Both normal cannot be used with absolute dot
+  // product values because one of the view planes may be flipped or one of the
+  // points may be at the same distance but in the opposite direction
+  const firstDistance = vec3.dot(firstViewPlaneNormal, firstPolyline[0]);
+  const secondDistance = vec3.dot(firstViewPlaneNormal, secondPolyline[0]);
+
+  return glMatrix.equals(firstDistance, secondDistance);
+}

package/src/utilities/contours/index.ts

@@ -1,3 +1,4 @@
+import areCoplanarContours from './areCoplanarContours';
 import contourFinder from './contourFinder';
 import mergePoints from './mergePoints';
 import detectContourHoles from './detectContourHoles';
@@ -8,6 +9,7 @@ import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 
 export {
+  areCoplanarContours,
   contourFinder,
   mergePoints,
   detectContourHoles,

package/src/utilities/contours/reverseIfAntiClockwise.ts

@@ -1,4 +1,5 @@
 import { Types } from '@cornerstonejs/core';
+import { getSignedArea } from '../math/polyline';
 
 /**
  * _reverseIfAntiClockwise - If the contour's nodes run anti-clockwise,
@@ -13,36 +14,16 @@ export default function reverseIfAntiClockwise(
   points: Types.Point2[],
   ...otherListsToReverse: unknown[][]
 ) {
-  const length = points.length;
-  if (!length) {
-    return points;
-  }
-  let xSum = 0;
-  for (const point of points) {
-    xSum += point[0];
-  }
-  const xMean = xSum / length;
-
-  let checkSum = 0;
+  const signedArea = getSignedArea(points);
 
-  for (let k = 0, i = 1, j = 2; k < length; k++) {
-    checkSum += (points[i][0] - xMean) * (points[j][1] - points[k][1]);
-    i++;
-    j++;
-    if (i >= length) {
-      i = 0;
-    }
-    if (j >= length) {
-      j = 0;
-    }
-  }
-
-  // Checksum will be less than zero for anti-clockwise
-  if (checkSum < 0) {
+  // signedArea will be less than zero for anti-clockwise
+  if (signedArea < 0) {
     if (otherListsToReverse) {
       otherListsToReverse.forEach((list) => list.reverse());
     }
+
     return points.slice().reverse();
   }
+
   return points;
 }

package/src/utilities/math/aabb/index.ts

@@ -1,2 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
 export { default as distanceToPoint } from './distanceToPoint';
 export { default as distanceToPointSquared } from './distanceToPointSquared';

package/src/utilities/math/aabb/intersectAABB.ts

@@ -0,0 +1,19 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Check if two axis-aligned bounding boxes intersect
+ * @param aabb1 - First AABB
+ * @param aabb2 - Second AABB
+ * @returns True if they intersect or false otherwise
+ */
+export default function intersectAABB(
+  aabb1: Types.AABB2,
+  aabb2: Types.AABB2
+): boolean {
+  return (
+    aabb1.minX <= aabb2.maxX &&
+    aabb1.maxX >= aabb2.minX &&
+    aabb1.minY <= aabb2.maxY &&
+    aabb1.maxY >= aabb2.minY
+  );
+}

package/src/utilities/math/point/distanceToPointSquared.ts

@@ -16,6 +16,11 @@ export default function distanceToPointSquared(p1: Point, p2: Point): number {
 
   const [x1, y1, z1 = 0] = p1;
   const [x2, y2, z2 = 0] = p2;
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const dz = z2 - z1;
 
-  return Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2) + Math.pow(z1 - z2, 2);
+  // Time to square 10M numbers:
+  //   (n * n) = 161ms | (n ** 2) = 199ms | Math.pow(n, 2) = 29529ms
+  return dx * dx + dy * dy + dz * dz;
 }

package/src/utilities/math/polyline/areLineSegmentsIntersecting.ts

@@ -0,0 +1,118 @@
+import type { Types } from '@cornerstonejs/core';
+
+// ATTENTION: this is an internal function and it should not be added to "polyline"
+// namespace.
+//
+// TODO: there is a similar function in math.lineSegment.intersectLine but we
+// need to investigate why it is 6x slower than this one when thousands of
+// intersections are calculated. Also that one may return [NaN, NaN] for
+// collinear points.
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects the line (`p2`,`q2`) via an
+ * orientation algorithm.
+ *
+ * Credit and details: geeksforgeeks.org/check-if-two-given-line-segments-intersect/
+ *
+ * @param p1 - Start point of line segment 1
+ * @param q1 - End point of line segment 1
+ * @param p2 - Start point of line segment 2
+ * @param q2 - End point of line segment 2
+ * @returns True if the line segments intersect or false otherwise
+ */
+export default function areLineSegmentsIntersecting(
+  p1: Types.Point2,
+  q1: Types.Point2,
+  p2: Types.Point2,
+  q2: Types.Point2
+): boolean {
+  let result = false;
+
+  // Line 1 AABB
+  const line1MinX = p1[0] < q1[0] ? p1[0] : q1[0];
+  const line1MinY = p1[1] < q1[1] ? p1[1] : q1[1];
+  const line1MaxX = p1[0] > q1[0] ? p1[0] : q1[0];
+  const line1MaxY = p1[1] > q1[1] ? p1[1] : q1[1];
+
+  // Line 2 AABB
+  const line2MinX = p2[0] < q2[0] ? p2[0] : q2[0];
+  const line2MinY = p2[1] < q2[1] ? p2[1] : q2[1];
+  const line2MaxX = p2[0] > q2[0] ? p2[0] : q2[0];
+  const line2MaxY = p2[1] > q2[1] ? p2[1] : q2[1];
+
+  // If AABBs do not intersect it is impossible for the lines to intersect.
+  // Checking AABB before doing any math makes it run ~12% faster.
+  if (
+    line1MinX > line2MaxX ||
+    line1MaxX < line2MinX ||
+    line1MinY > line2MaxY ||
+    line1MaxY < line2MinY
+  ) {
+    return false;
+  }
+
+  const orient = [
+    orientation(p1, q1, p2),
+    orientation(p1, q1, q2),
+    orientation(p2, q2, p1),
+    orientation(p2, q2, q1),
+  ];
+
+  // General Case
+  if (orient[0] !== orient[1] && orient[2] !== orient[3]) {
+    return true;
+  }
+
+  // Special Cases
+  if (orient[0] === 0 && onSegment(p1, p2, q1)) {
+    // If p1, q1 and p2 are colinear and p2 lies on segment p1q1
+    result = true;
+  } else if (orient[1] === 0 && onSegment(p1, q2, q1)) {
+    // If p1, q1 and p2 are colinear and q2 lies on segment p1q1
+    result = true;
+  } else if (orient[2] === 0 && onSegment(p2, p1, q2)) {
+    // If p2, q2 and p1 are colinear and p1 lies on segment p2q2
+    result = true;
+  } else if (orient[3] === 0 && onSegment(p2, q1, q2)) {
+    // If p2, q2 and q1 are colinear and q1 lies on segment p2q2
+    result = true;
+  }
+
+  return result;
+}
+
+/**
+ * Checks the orientation of 3 points, returns a 0, 1 or 2 based on
+ * the orientation of the points.
+ */
+function orientation(
+  p: Types.Point2,
+  q: Types.Point2,
+  r: Types.Point2
+): number {
+  // Take the cross product between vectors PQ and QR
+  const orientationValue =
+    (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);
+
+  if (orientationValue === 0) {
+    return 0; // Colinear
+  }
+
+  return orientationValue > 0 ? 1 : 2;
+}
+
+/**
+ * Checks if point `q` lies on the segment (`p`,`r`).
+ */
+function onSegment(p: Types.Point2, q: Types.Point2, r: Types.Point2): boolean {
+  if (
+    q[0] <= Math.max(p[0], r[0]) &&
+    q[0] >= Math.min(p[0], r[0]) &&
+    q[1] <= Math.max(p[1], r[1]) &&
+    q[1] >= Math.min(p[1], r[1])
+  ) {
+    return true;
+  }
+
+  return false;
+}