@cornerstonejs/tools 2.0.0-beta.2 → 2.0.0-beta.3

package/src/tools/OverlayGridTool.ts

@@ -0,0 +1,357 @@
+import { vec3 } from 'gl-matrix';
+import {
+  metaData,
+  CONSTANTS,
+  getRenderingEngine,
+  utilities as csUtils,
+} from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+import {
+  addAnnotation,
+  getAnnotations,
+} from '../stateManagement/annotation/annotationState';
+
+import { getToolGroup } from '../store/ToolGroupManager';
+
+import { drawLine as drawLineSvg } from '../drawingSvg';
+import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
+
+import {
+  PublicToolProps,
+  ToolProps,
+  SVGDrawingHelper,
+  Annotation,
+} from '../types';
+import { StyleSpecifier } from '../types/AnnotationStyle';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+
+const { EPSILON } = CONSTANTS;
+
+export interface OverlayGridAnnotation extends Annotation {
+  data: {
+    viewportData: Map<string, object>;
+    pointSets: Array<object>;
+  };
+}
+
+/**
+ * @public
+ */
+class OverlayGridTool extends AnnotationDisplayTool {
+  static toolName;
+
+  public touchDragCallback: any;
+  public mouseDragCallback: any;
+  _throttledCalculateCachedStats: any;
+  isDrawing: boolean;
+  isHandleOutsideImage: boolean;
+
+  constructor(
+    toolProps: PublicToolProps = {},
+    defaultToolProps: ToolProps = {
+      supportedInteractionTypes: ['Mouse', 'Touch'],
+      configuration: {
+        sourceImageIds: [],
+      },
+    }
+  ) {
+    super(toolProps, defaultToolProps);
+  }
+
+  onSetToolEnabled = (): void => {
+    this._init();
+  };
+
+  onSetToolActive = (): void => {
+    this._init();
+  };
+
+  _init = (): void => {
+    const sourceImageIds = this.configuration.sourceImageIds;
+    if (!sourceImageIds?.length) {
+      console.warn(
+        'OverlayGridTool: No sourceImageIds provided in configuration'
+      );
+      return;
+    }
+
+    const imagePlaneModule = metaData.get(
+      'imagePlaneModule',
+      sourceImageIds[0]
+    );
+
+    if (!imagePlaneModule) {
+      console.warn(
+        'OverlayGridTool: No imagePlaneModule found for sourceImageIds'
+      );
+      return;
+    }
+
+    const { frameOfReferenceUID } = imagePlaneModule;
+
+    const viewportsInfo = getToolGroup(this.toolGroupId).viewportsInfo;
+
+    if (!viewportsInfo?.length) {
+      console.warn('OverlayGridTool: No viewports found');
+      return;
+    }
+
+    const annotations = getAnnotations(this.getToolName(), frameOfReferenceUID);
+
+    if (!annotations?.length) {
+      const pointSets = sourceImageIds.map((id) => {
+        // check if pointSets for the imageId was calculated. If not calculate and store
+        return this.calculateImageIdPointSets(id);
+      });
+
+      const newAnnotation: OverlayGridAnnotation = {
+        highlighted: true,
+        invalidated: true,
+        metadata: {
+          toolName: this.getToolName(),
+          FrameOfReferenceUID: frameOfReferenceUID,
+          referencedImageId: null,
+        },
+        data: {
+          viewportData: new Map(),
+          pointSets,
+        },
+      };
+
+      addAnnotation(newAnnotation, frameOfReferenceUID);
+    }
+
+    triggerAnnotationRenderForViewportIds(
+      getRenderingEngine(viewportsInfo[0].renderingEngineId),
+      viewportsInfo.map(({ viewportId }) => viewportId)
+    );
+  };
+
+  /**
+   * Calculates the point sets based on the image corners relative to an imageId
+   * @param imageId - The imageId to calculate the point sets for
+   * @returns
+   */
+  calculateImageIdPointSets = (imageId: string) => {
+    const {
+      imagePositionPatient,
+      rows,
+      columns,
+      rowCosines,
+      columnCosines,
+      rowPixelSpacing,
+      columnPixelSpacing,
+    } = metaData.get('imagePlaneModule', imageId);
+
+    // top left world, top right world, bottom right world, bottom left world
+    const topLeft = <Types.Point3>[...imagePositionPatient];
+    const topRight = <Types.Point3>[...imagePositionPatient];
+    const bottomLeft = <Types.Point3>[...imagePositionPatient];
+    const bottomRight = <Types.Point3>[...imagePositionPatient];
+
+    vec3.scaleAndAdd(
+      topRight,
+      imagePositionPatient,
+      columnCosines,
+      columns * columnPixelSpacing
+    );
+    vec3.scaleAndAdd(
+      bottomLeft,
+      imagePositionPatient,
+      rowCosines,
+      rows * rowPixelSpacing
+    );
+
+    vec3.scaleAndAdd(
+      bottomRight,
+      bottomLeft,
+      columnCosines,
+      columns * columnPixelSpacing
+    );
+
+    // check if the topLeft and bottomLeft line is parallel to the viewUp
+    const pointSet1 = [topLeft, bottomLeft, topRight, bottomRight];
+    const pointSet2 = [topLeft, topRight, bottomLeft, bottomRight];
+
+    return { pointSet1, pointSet2 };
+  };
+
+  /**
+   * it is used to draw the length annotation in each
+   * request animation frame. It calculates the updated cached statistics if
+   * data is invalidated and cache it.
+   *
+   * @param enabledElement - The Cornerstone's enabledElement.
+   * @param svgDrawingHelper - The svgDrawingHelper providing the context for drawing.
+   */
+  renderAnnotation = (
+    enabledElement: Types.IEnabledElement,
+    svgDrawingHelper: SVGDrawingHelper
+  ): boolean => {
+    const sourceImageIds = this.configuration.sourceImageIds;
+
+    let renderStatus = false;
+    if (!sourceImageIds?.length) {
+      return renderStatus;
+    }
+
+    const { viewport: targetViewport, FrameOfReferenceUID } = enabledElement;
+    const targetImageIds = targetViewport.getImageIds();
+    if (targetImageIds.length < 2) {
+      return renderStatus;
+    }
+
+    const annotations = getAnnotations(this.getToolName(), FrameOfReferenceUID);
+    if (!annotations?.length) {
+      return renderStatus;
+    }
+    const annotation = annotations[0];
+    const { annotationUID } = annotation;
+
+    const { focalPoint, viewPlaneNormal } = targetViewport.getCamera();
+
+    const styleSpecifier: StyleSpecifier = {
+      toolGroupId: this.toolGroupId,
+      toolName: this.getToolName(),
+      viewportId: enabledElement.viewport.id,
+    };
+    const imageIdNormal = <Types.Point3>(
+      this.getImageIdNormal(sourceImageIds[0])
+    );
+
+    if (this.isParallel(viewPlaneNormal, imageIdNormal)) {
+      // If the source and target viewports are parallel, we don't need to render
+      return renderStatus;
+    }
+
+    const targetViewportPlane = csUtils.planar.planeEquation(
+      viewPlaneNormal,
+      focalPoint
+    );
+
+    const pointSets = annotation.data.pointSets;
+    const viewportData = annotation.data.viewportData;
+    for (let i = 0; i < sourceImageIds.length; i++) {
+      // check if pointSets for the imageId was calculated. If not calculate and store
+      const { pointSet1, pointSet2 } = pointSets[i];
+
+      const targetData =
+        viewportData.get(targetViewport.id) ||
+        this.initializeViewportData(viewportData, targetViewport.id);
+
+      // check if pointSetToUse was calculated. If not calculate and store
+      if (!targetData.pointSetsToUse[i]) {
+        let pointSetToUse = pointSet1;
+
+        let topBottomVec = vec3.subtract(
+          vec3.create(),
+          pointSet1[0],
+          pointSet1[1]
+        );
+        topBottomVec = vec3.normalize(
+          vec3.create(),
+          topBottomVec
+        ) as Types.Point3;
+
+        // check if it is perpendicular to the viewPlaneNormal which means
+        // the line does not intersect the viewPlaneNormal
+        if (this.isPerpendicular(topBottomVec, viewPlaneNormal)) {
+          // 'use pointSet2';
+          pointSetToUse = pointSet2;
+        }
+
+        targetData.pointSetsToUse[i] = pointSetToUse;
+
+        targetData.lineStartsWorld[i] = csUtils.planar.linePlaneIntersection(
+          pointSetToUse[0],
+          pointSetToUse[1],
+          targetViewportPlane
+        );
+
+        targetData.lineEndsWorld[i] = csUtils.planar.linePlaneIntersection(
+          pointSetToUse[2],
+          pointSetToUse[3],
+          targetViewportPlane
+        );
+      }
+
+      const lineStartWorld = targetData.lineStartsWorld[i];
+      const lineEndWorld = targetData.lineEndsWorld[i];
+
+      styleSpecifier.annotationUID = annotationUID;
+      const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+      const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+      const color = this.getStyle('color', styleSpecifier, annotation);
+      const shadow = this.getStyle('shadow', styleSpecifier, annotation);
+
+      const canvasCoordinates = [lineStartWorld, lineEndWorld].map((world) =>
+        targetViewport.worldToCanvas(world)
+      );
+
+      const dataId = `${annotationUID}-line`;
+      const lineUID = `${i}`;
+      drawLineSvg(
+        svgDrawingHelper,
+        annotationUID,
+        lineUID,
+        canvasCoordinates[0],
+        canvasCoordinates[1],
+        {
+          color,
+          width: lineWidth,
+          lineDash,
+          shadow,
+        },
+        dataId
+      );
+    }
+
+    renderStatus = true;
+
+    return renderStatus;
+  };
+
+  private initializeViewportData = (viewportData, id) => {
+    viewportData.set(id, {
+      pointSetsToUse: [],
+      lineStartsWorld: [],
+      lineEndsWorld: [],
+    });
+
+    return viewportData.get(id);
+  };
+
+  private isPerpendicular = (
+    vec1: Types.Point3,
+    vec2: Types.Point3
+  ): boolean => {
+    const dot = vec3.dot(vec1, vec2);
+    return Math.abs(dot) < EPSILON;
+  };
+
+  private isParallel(vec1: Types.Point3, vec2: Types.Point3): boolean {
+    return Math.abs(vec3.dot(vec1, vec2)) > 1 - EPSILON;
+  }
+
+  private getImageIdNormal(imageId: string): vec3 {
+    const { imageOrientationPatient } = metaData.get(
+      'imagePlaneModule',
+      imageId
+    );
+    const rowCosineVec = vec3.fromValues(
+      imageOrientationPatient[0],
+      imageOrientationPatient[1],
+      imageOrientationPatient[2]
+    );
+    const colCosineVec = vec3.fromValues(
+      imageOrientationPatient[3],
+      imageOrientationPatient[4],
+      imageOrientationPatient[5]
+    );
+    return vec3.cross(vec3.create(), rowCosineVec, colCosineVec);
+  }
+}
+
+OverlayGridTool.toolName = 'OverlayGrid';
+export default OverlayGridTool;

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/AngleTool.ts

@@ -658,7 +658,10 @@ class AngleTool extends AnnotationTool {
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
 
       // WE HAVE TO CACHE STATS BEFORE FETCHING TEXT
-      if (!data.cachedStats[targetId]) {
+      if (
+        !data.cachedStats[targetId] ||
+        data.cachedStats[targetId].angle == null
+      ) {
         data.cachedStats[targetId] = {
           angle: null,
         };

package/src/tools/annotation/BidirectionalTool.ts

@@ -1073,7 +1073,7 @@ class BidirectionalTool extends AnnotationTool {
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].unit === undefined
+        data.cachedStats[targetId].unit == null
       ) {
         data.cachedStats[targetId] = {
           length: null,

package/src/tools/annotation/CircleROITool.ts

@@ -44,7 +44,6 @@ import {
   TextBoxHandle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { CircleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
@@ -52,8 +51,6 @@ import { CircleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import {
   AnnotationCompletedEventDetail,
   AnnotationModifiedEventDetail,
-  MouseDragEventType,
-  MouseMoveEventType,
 } from '../../types/EventTypes';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { pointInShapeCallback } from '../../utilities';
@@ -678,21 +675,11 @@ class CircleROITool extends AnnotationTool {
 
       const { centerPointRadius } = this.configuration;
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
       // If cachedStats does not exist, or the unit is missing (as part of import/hydration etc.),
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].areaUnit === undefined
+        data.cachedStats[targetId].areaUnit == null
       ) {
         data.cachedStats[targetId] = {
           Modality: null,
@@ -710,16 +697,14 @@ class CircleROITool extends AnnotationTool {
           annotation,
           viewport,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
       } else if (annotation.invalidated) {
         this._throttledCalculateCachedStats(
           annotation,
           viewport,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
         // If the invalidated data is as a result of volumeViewport manipulation
         // of the tools, we need to invalidate the related viewports data, so that
@@ -889,8 +874,7 @@ class CircleROITool extends AnnotationTool {
     annotation,
     viewport,
     renderingEngine,
-    enabledElement,
-    modalityUnitOptions: ModalityUnitOptions
+    enabledElement
   ) => {
     const data = annotation.data;
     const { viewportId, renderingEngineId } = enabledElement;
@@ -985,6 +969,15 @@ class CircleROITool extends AnnotationTool {
             (worldHeight / aspect / scale / 2)
         );
 
+        const modalityUnitOptions = {
+          isPreScaled: isViewportPreScaled(viewport, targetId),
+          isSuvScaled: this.isSuvScaled(
+            viewport,
+            targetId,
+            annotation.metadata.referencedImageId
+          ),
+        };
+
         const modalityUnit = getModalityUnit(
           metadata.Modality,
           annotation.metadata.referencedImageId,