@cornerstonejs/tools 2.0.0-beta.1 → 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/PlanarRotateTool.ts

@@ -56,7 +56,9 @@ class PlanarRotateTool extends BaseTool {
       angle = -angle;
     }
 
-    if (Number.isNaN(angle)) return;
+    if (Number.isNaN(angle)) {
+      return;
+    }
 
     if (viewport instanceof BaseVolumeViewport) {
       const rotAngle = (angle * Math.PI) / 180;

package/src/tools/ReferenceCursors.ts

@@ -104,26 +104,38 @@ class ReferenceCursors extends AnnotationDisplayTool {
 
   onSetToolActive(): void {
     this._disableCursorEnabled = this.configuration.disableCursor;
-    if (!this._disableCursorEnabled) return;
+    if (!this._disableCursorEnabled) {
+      return;
+    }
     const viewportIds = getToolGroup(this.toolGroupId).viewportsInfo;
-    if (!viewportIds) return;
+    if (!viewportIds) {
+      return;
+    }
     const enabledElements = viewportIds.map((e) =>
       getEnabledElementByIds(e.viewportId, e.renderingEngineId)
     );
 
     enabledElements.forEach((element) => {
-      if (element) hideElementCursor(element.viewport.element);
+      if (element) {
+        hideElementCursor(element.viewport.element);
+      }
     });
   }
   onSetToolDisabled(): void {
-    if (!this._disableCursorEnabled) return;
+    if (!this._disableCursorEnabled) {
+      return;
+    }
     const viewportIds = getToolGroup(this.toolGroupId).viewportsInfo;
-    if (!viewportIds) return;
+    if (!viewportIds) {
+      return;
+    }
     const enabledElements = viewportIds.map((e) =>
       getEnabledElementByIds(e.viewportId, e.renderingEngineId)
     );
     enabledElements.forEach((element) => {
-      if (element) resetElementCursor(element.viewport.element);
+      if (element) {
+        resetElementCursor(element.viewport.element);
+      }
     });
   }
 
@@ -132,14 +144,18 @@ class ReferenceCursors extends AnnotationDisplayTool {
     element: HTMLDivElement
   ): void => {
     const enabledElement = getEnabledElement(element);
-    if (!enabledElement) throw new Error('No enabled element found');
+    if (!enabledElement) {
+      throw new Error('No enabled element found');
+    }
     const { viewport, renderingEngine } = enabledElement;
 
     this.isDrawing = true;
 
     const camera = viewport.getCamera();
     const { viewPlaneNormal, viewUp } = camera;
-    if (!viewPlaneNormal || !viewUp) throw new Error('Camera not found');
+    if (!viewPlaneNormal || !viewUp) {
+      throw new Error('Camera not found');
+    }
 
     const referencedImageId = this.getReferencedImageId(
       viewport,
@@ -181,10 +197,14 @@ class ReferenceCursors extends AnnotationDisplayTool {
 
     const annotations = getAnnotations(this.getToolName(), element);
 
-    if (annotations.length > 0) return null;
+    if (annotations.length > 0) {
+      return null;
+    }
     const annotationId = addAnnotation(annotation, element);
 
-    if (annotationId === null) return;
+    if (annotationId === null) {
+      return;
+    }
 
     const viewportIdsToRender = getViewportIdsWithToolToRender(
       element,
@@ -212,8 +232,12 @@ class ReferenceCursors extends AnnotationDisplayTool {
     annotation: Annotation
   ): void {
     const worldPos = this._currentCursorWorldPosition;
-    if (!worldPos) return;
-    if (!annotation.data?.handles?.points) return;
+    if (!worldPos) {
+      return;
+    }
+    if (!annotation.data?.handles?.points) {
+      return;
+    }
     annotation.data.handles.points = [[...worldPos]];
     annotation.invalidated = true;
 
@@ -223,7 +247,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       false
     );
     const enabledElement = getEnabledElement(element);
-    if (!enabledElement) return;
+    if (!enabledElement) {
+      return;
+    }
     const { renderingEngine } = enabledElement;
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
   }
@@ -238,7 +264,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       | Types.IStackViewport;
 
     //only react to changes for element with cursor, otherwise would cause infinite loop
-    if (element !== this._elementWithCursor) return;
+    if (element !== this._elementWithCursor) {
+      return;
+    }
     //check if camera moved along its normal
     const oldFocalPoint = previousCamera.focalPoint;
     const cameraNormal = camera.viewPlaneNormal;
@@ -247,14 +275,20 @@ class ReferenceCursors extends AnnotationDisplayTool {
     const deltaCameraFocalPoint: Types.Point3 = [0, 0, 0];
     vtkMath.subtract(newFocalPoint, oldFocalPoint, deltaCameraFocalPoint);
     //check if focal point changed
-    if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) return;
+    if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) {
+      return;
+    }
     //if nomrmal is perpendicular to focal point change, then we are not moving along the normal
     const dotProduct = vtkMath.dot(deltaCameraFocalPoint, cameraNormal);
     //dot product is 0 -> perpendicular
-    if (Math.abs(dotProduct) < 1e-2) return;
+    if (Math.abs(dotProduct) < 1e-2) {
+      return;
+    }
 
     //need to update the position of the annotation since camera changed
-    if (!this._currentCanvasPosition) return;
+    if (!this._currentCanvasPosition) {
+      return;
+    }
 
     const newWorldPos = viewport.canvasToWorld(this._currentCanvasPosition);
     this._currentCursorWorldPosition = newWorldPos;
@@ -267,15 +301,23 @@ class ReferenceCursors extends AnnotationDisplayTool {
     annotations: Annotations
   ): Annotations {
     //calculate distance of current viewport to annotation
-    if (!(annotations instanceof Array) || annotations.length === 0) return [];
+    if (!(annotations instanceof Array) || annotations.length === 0) {
+      return [];
+    }
     const annotation = annotations[0];
     const viewport = getEnabledElement(element)?.viewport;
-    if (!viewport) return [];
+    if (!viewport) {
+      return [];
+    }
     const camera = viewport.getCamera();
     const { viewPlaneNormal, focalPoint } = camera;
-    if (!viewPlaneNormal || !focalPoint) return [];
+    if (!viewPlaneNormal || !focalPoint) {
+      return [];
+    }
     const points = annotation.data?.handles?.points;
-    if (!(points instanceof Array) || points.length !== 1) return [];
+    if (!(points instanceof Array) || points.length !== 1) {
+      return [];
+    }
     const worldPos = points[0];
     const plane = utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
     const distance = utilities.planar.planeDistanceToPoint(plane, worldPos);
@@ -333,7 +375,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       const { handles } = data;
       const { points } = handles;
 
-      if (!annotationUID) return renderStatus;
+      if (!annotationUID) {
+        return renderStatus;
+      }
       styleSpecifier.annotationUID = annotationUID;
 
       const lineWidthBase = parseFloat(
@@ -347,7 +391,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
       const color = this.getStyle('color', styleSpecifier, annotation);
 
-      if (points[0].some((e) => isNaN(e))) return renderStatus;
+      if (points[0].some((e) => isNaN(e))) {
+        return renderStatus;
+      }
       const canvasCoordinates = points.map((p) =>
         viewport.worldToCanvas(p)
       ) as [Types.Point2];
@@ -414,8 +460,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
   ): void {
     const currentMousePosition = this._currentCursorWorldPosition;
 
-    if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e)))
+    if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e))) {
       return;
+    }
 
     if (viewport instanceof StackViewport) {
       const closestIndex = utilities.getClosestStackImageIndexForPoint(
@@ -423,12 +470,17 @@ class ReferenceCursors extends AnnotationDisplayTool {
         viewport
       );
 
-      if (closestIndex === null) return;
-      if (closestIndex !== viewport.getCurrentImageIdIndex())
+      if (closestIndex === null) {
+        return;
+      }
+      if (closestIndex !== viewport.getCurrentImageIdIndex()) {
         viewport.setImageIdIndex(closestIndex);
+      }
     } else if (viewport instanceof VolumeViewport) {
       const { focalPoint, viewPlaneNormal } = viewport.getCamera();
-      if (!focalPoint || !viewPlaneNormal) return;
+      if (!focalPoint || !viewPlaneNormal) {
+        return;
+      }
       const plane = utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
       const currentDistance = utilities.planar.planeDistanceToPoint(
         plane,
@@ -436,7 +488,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
         true
       );
 
-      if (Math.abs(currentDistance) < 0.5) return;
+      if (Math.abs(currentDistance) < 0.5) {
+        return;
+      }
       const normalizedViewPlane = vec3.normalize(
         vec3.create(),
         vec3.fromValues(...viewPlaneNormal)
@@ -456,7 +510,9 @@ class ReferenceCursors extends AnnotationDisplayTool {
       if (isInBounds) {
         viewport.setCamera({ focalPoint: newFocalPoint });
         const renderingEngine = viewport.getRenderingEngine();
-        if (renderingEngine) renderingEngine.renderViewport(viewport.id);
+        if (renderingEngine) {
+          renderingEngine.renderViewport(viewport.id);
+        }
       }
     }
   }