@cornerstonejs/tools 1.21.1 → 1.22.0

package/src/tools/base/AnnotationTool.ts

@@ -94,7 +94,8 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
   abstract toolSelectedCallback(
     evt: EventTypes.InteractionEventType,
     annotation: Annotation,
-    interactionType: InteractionTypes
+    interactionType: InteractionTypes,
+    canvasCoords?: Types.Point2
   ): void;
 
   /**

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

@@ -129,7 +129,6 @@ async function render(
   const contourData = segmentation.representationData[Representations.Contour];
   const { geometryIds } = contourData;
 
-
   // We don't have a good way to handle stack viewports for contours at the moment.
   // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
   if (viewport instanceof StackViewport) {

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -273,6 +273,7 @@ export interface ArrowAnnotation extends Annotation {
     };
   };
 }
+
 export interface AngleAnnotation extends Annotation {
   data: {
     handles: {
@@ -298,6 +299,51 @@ export interface AngleAnnotation extends Annotation {
   };
 }
 
+export interface CobbAngleAnnotation extends Annotation {
+  data: {
+    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;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        angle: number;
+        arc1Angle: number;
+        arc2Angle: number;
+        points: {
+          world: {
+            arc1Start: Types.Point3;
+            arc1End: Types.Point3;
+            arc2Start: Types.Point3;
+            arc2End: Types.Point3;
+            arc1Angle: number;
+            arc2Angle: number;
+          };
+          canvas: {
+            arc1Start: Types.Point2;
+            arc1End: Types.Point2;
+            arc2Start: Types.Point2;
+            arc2End: Types.Point2;
+            arc1Angle: number;
+            arc2Angle: number;
+          };
+        };
+      };
+    };
+  };
+}
+
 export interface ReferenceCursor extends Annotation {
   data: {
     handles: {

package/src/utilities/math/angle/angleBetweenLines.ts

@@ -1,17 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
 
-type Line = [Types.Point3, Types.Point3];
+type Line2D = [Types.Point2, Types.Point2];
+type Line3D = [Types.Point3, Types.Point3];
+type Line = Line2D | Line3D;
 
 /**
- * It returns the angle between two lines in degrees.
- * The angle measured is that between the vectors
- * line1[1]->line1[0] AND line2[0]->line2[1].
- * @param line1 - Line = [p1, p2]
- * @param line2 - Line = [p3, p4]
- * @returns The angle between two lines in degrees.
+ * Calculates the angle between two 3D lines.
  */
-export default function angleBetweenLines(line1: Line, line2: Line): number {
+function angleBetween3DLines(line1: Line3D, line2: Line3D): number {
   const [p1, p2] = line1;
   const [p3, p4] = line2;
 
@@ -29,3 +26,36 @@ export default function angleBetweenLines(line1: Line, line2: Line): number {
 
   return (radian * 180) / Math.PI;
 }
+
+/**
+ * Calculates the angle between two 2D lines.
+ */
+function angleBetween2DLines(line1: Line2D, line2: Line2D): number {
+  const [p1, p2] = line1;
+  const [p3, p4] = line2;
+
+  const v1 = vec2.sub(vec2.create(), p2, p1);
+  const v2 = vec2.sub(vec2.create(), p3, p4);
+
+  const dot = vec2.dot(v1, v2);
+  const v1Length = vec2.length(v1);
+  const v2Length = vec2.length(v2);
+
+  const cos = dot / (v1Length * v2Length);
+  return Math.acos(cos) * (180 / Math.PI);
+}
+
+/**
+ * Returns the angle between two lines in degrees.
+ * The angle measured is that between the vectors
+ * line1[1]->line1[0] AND line2[0]->line2[1].
+ * @param line1 - Line = [p1, p2]
+ * @param line2 - Line = [p3, p4]
+ * @returns The angle between two lines in degrees.
+ */
+export default function angleBetweenLines(line1: Line, line2: Line): number {
+  const is3D = line1[0].length === 3;
+  return is3D
+    ? angleBetween3DLines(line1 as Line3D, line2 as Line3D)
+    : angleBetween2DLines(line1 as Line2D, line2 as Line2D);
+}