@cornerstonejs/tools 1.18.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.18.0",
+    "@cornerstonejs/core": "^1.19.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "a3a41620de2a91c64588493e6a332c3808145e91"
+  "gitHead": "5b0292ff4c77ab9472898ad24e266c01068387b7"
 }

package/src/tools/ReferenceLinesTool.ts

@@ -11,7 +11,6 @@ import { addAnnotation } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg } from '../drawingSvg';
 import { filterViewportsWithToolEnabled } from '../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-
 import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import { StyleSpecifier } from '../types/AnnotationStyle';
@@ -43,6 +42,7 @@ class ReferenceLines extends AnnotationDisplayTool {
       supportedInteractionTypes: ['Mouse', 'Touch'],
       configuration: {
         sourceViewportId: '',
+        showFullDimension: false,
       },
     }
   ) {
@@ -177,7 +177,7 @@ class ReferenceLines extends AnnotationDisplayTool {
     const bottomLeft = annotation.data.handles.points[2];
     const bottomRight = annotation.data.handles.points[3];
 
-    const { focalPoint, viewPlaneNormal } = targetViewport.getCamera();
+    const { focalPoint, viewPlaneNormal, viewUp } = targetViewport.getCamera();
     const { viewPlaneNormal: sourceViewPlaneNormal } =
       sourceViewport.getCamera();
 
@@ -239,10 +239,21 @@ class ReferenceLines extends AnnotationDisplayTool {
     const color = this.getStyle('color', styleSpecifier, annotation);
     const shadow = this.getStyle('shadow', styleSpecifier, annotation);
 
-    const canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) =>
+    let canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) =>
       targetViewport.worldToCanvas(world)
     );
 
+    if (this.configuration.showFullDimension) {
+      canvasCoordinates = this.handleFullDimension(
+        targetViewport,
+        lineStartWorld,
+        viewPlaneNormal,
+        viewUp,
+        lineEndWorld,
+        canvasCoordinates
+      );
+    }
+
     const dataId = `${annotationUID}-line`;
     const lineUID = '1';
     drawLineSvg(
@@ -270,9 +281,126 @@ class ReferenceLines extends AnnotationDisplayTool {
     return Math.abs(dot) < EPSILON;
   };
 
+  private handleFullDimension(
+    targetViewport: Types.IStackViewport | Types.IVolumeViewport,
+    lineStartWorld: Types.Point3,
+    viewPlaneNormal: Types.Point3,
+    viewUp: Types.Point3,
+    lineEndWorld: Types.Point3,
+    canvasCoordinates: Types.Point2[]
+  ) {
+    const renderingEngine = targetViewport.getRenderingEngine();
+    const targetId = this.getTargetId(targetViewport);
+    const targetImage = this.getTargetIdImage(targetId, renderingEngine);
+
+    const referencedImageId = this.getReferencedImageId(
+      targetViewport,
+      lineStartWorld,
+      viewPlaneNormal,
+      viewUp
+    );
+
+    if (referencedImageId && targetImage) {
+      try {
+        const { imageData, dimensions } = targetImage;
+
+        // Calculate bound image coordinates
+        const [
+          topLeftImageCoord,
+          topRightImageCoord,
+          bottomRightImageCoord,
+          bottomLeftImageCoord,
+        ] = [
+          imageData.indexToWorld([0, 0, 0]) as Types.Point3,
+          imageData.indexToWorld([dimensions[0] - 1, 0, 0]) as Types.Point3,
+          imageData.indexToWorld([
+            dimensions[0] - 1,
+            dimensions[1] - 1,
+            0,
+          ]) as Types.Point3,
+          imageData.indexToWorld([0, dimensions[1] - 1, 0]) as Types.Point3,
+        ].map((world) => csUtils.worldToImageCoords(referencedImageId, world));
+
+        // Calculate line start and end image coordinates
+        const [lineStartImageCoord, lineEndImageCoord] = [
+          lineStartWorld,
+          lineEndWorld,
+        ].map((world) => csUtils.worldToImageCoords(referencedImageId, world));
+
+        // Calculate intersection points between line and image bounds
+        canvasCoordinates = [
+          [topLeftImageCoord, topRightImageCoord],
+          [topRightImageCoord, bottomRightImageCoord],
+          [bottomLeftImageCoord, bottomRightImageCoord],
+          [topLeftImageCoord, bottomLeftImageCoord],
+        ]
+          .map(([start, end]) =>
+            this.intersectInfiniteLines(
+              start,
+              end,
+              lineStartImageCoord,
+              lineEndImageCoord
+            )
+          )
+          .filter((point) => point && this.isInBound(point, dimensions))
+          .map((point) => {
+            const world = csUtils.imageToWorldCoords(
+              referencedImageId,
+              point as Types.Point2
+            );
+            return targetViewport.worldToCanvas(world);
+          });
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    return canvasCoordinates;
+  }
+
+  // get the intersection point between two infinite lines, not line segments
+  intersectInfiniteLines(
+    line1Start: Types.Point2,
+    line1End: Types.Point2,
+    line2Start: Types.Point2,
+    line2End: Types.Point2
+  ) {
+    const [x1, y1] = line1Start;
+    const [x2, y2] = line1End;
+    const [x3, y3] = line2Start;
+    const [x4, y4] = line2End;
+
+    // Compute a1, b1, c1, where line joining points 1 and 2 is "a1 x  +  b1 y  +  c1  =  0"
+    const a1 = y2 - y1;
+    const b1 = x1 - x2;
+    const c1 = x2 * y1 - x1 * y2;
+
+    // Compute a2, b2, c2
+    const a2 = y4 - y3;
+    const b2 = x3 - x4;
+    const c2 = x4 * y3 - x3 * y4;
+
+    if (Math.abs(a1 * b2 - a2 * b1) < EPSILON) {
+      return;
+    }
+
+    const x = (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
+    const y = (a2 * c1 - a1 * c2) / (a1 * b2 - a2 * b1);
+
+    return [x, y];
+  }
+
   isParallel(vec1: Types.Point3, vec2: Types.Point3): boolean {
     return Math.abs(vec3.dot(vec1, vec2)) > 1 - EPSILON;
   }
+
+  isInBound(point: number[], dimensions: Types.Point3): boolean {
+    return (
+      point[0] >= 0 &&
+      point[0] <= dimensions[0] &&
+      point[1] >= 0 &&
+      point[1] <= dimensions[1]
+    );
+  }
 }
 
 ReferenceLines.toolName = 'ReferenceLines';

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -44,14 +44,13 @@ import {
   AnnotationStyle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
-import { drawLine, drawCircle, drawLinkedTextBox } from '../../drawingSvg';
+import { drawLinkedTextBox } from '../../drawingSvg';
 import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { PlanarFreehandROICommonData } from '../../utilities/math/polyline/planarFreehandROIInternalTypes';
-import pointInPolyline from '../../utilities/math/polyline/pointInPolyline';
+
 import { getIntersectionCoordinatesWithPolyline } from '../../utilities/math/polyline/getIntersectionWithPolyline';
 import pointInShapeCallback from '../../utilities/pointInShapeCallback';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
@@ -752,9 +751,28 @@ class PlanarFreehandROITool extends AnnotationTool {
 
       const { imageData, metadata } = image;
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+
+      // Using an arbitrary start point (canvasPoint), calculate the
+      // mm spacing for the canvas in the X and Y directions.
+      const canvasPoint = canvasCoordinates[0];
+      const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+      const deltaXPoint = viewport.canvasToWorld([
+        canvasPoint[0] + 1,
+        canvasPoint[1],
+      ]);
+      const deltaYPoint = viewport.canvasToWorld([
+        canvasPoint[0],
+        canvasPoint[1] + 1,
+      ]);
+
+      const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
+      const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
+
       const scale = getCalibratedScale(image);
-      const area =
+      let area =
         polyline.calculateAreaOfPoints(canvasCoordinates) / scale / scale;
+      // Convert from canvas_pixels ^2 to mm^2
+      area *= deltaInX * deltaInY;
 
       const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
       worldPosIndex[0] = Math.floor(worldPosIndex[0]);

package/src/tools/base/AnnotationDisplayTool.ts

@@ -102,6 +102,10 @@ abstract class AnnotationDisplayTool extends BaseTool {
 
       // for this specific tool
       toolSpecificAnnotations.forEach((annotation) => {
+        if (!annotation.metadata?.referencedImageId) {
+          return;
+        }
+
         // if the annotation is drawn on the same imageId
         const referencedImageURI = utilities.imageIdToURI(
           annotation.metadata.referencedImageId