@cornerstonejs/tools 1.78.3 → 1.80.0

package/src/tools/segmentation/RectangleROIStartEndThresholdTool.ts

@@ -2,11 +2,11 @@ import {
   getEnabledElement,
   cache,
   StackViewport,
-  metaData,
   utilities as csUtils,
 } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
+import { Types, utilities as coreUtils } from '@cornerstonejs/core';
 
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { vec3 } from 'gl-matrix';
 import {
   addAnnotation,
@@ -14,20 +14,26 @@ import {
   removeAnnotation,
 } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import {
   drawHandles as drawHandlesSvg,
   drawRect as drawRectSvg,
+  drawLinkedTextBox as drawLinkedTextBoxSvg,
 } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
+
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import {
   hideElementCursor,
   resetElementCursor,
 } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { triggerAnnotationCompleted } from '../../stateManagement/annotation/helpers/state';
+import {
+  triggerAnnotationCompleted,
+  triggerAnnotationModified,
+} from '../../stateManagement/annotation/helpers/state';
 
 import {
   PublicToolProps,
@@ -38,7 +44,11 @@ import {
 import { RectangleROIStartEndThresholdAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import RectangleROITool from '../annotation/RectangleROITool';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
-import { pointInShapeCallback } from '../../utilities/';
+import { pointInShapeCallback, roundNumber } from '../../utilities/';
+import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
+import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -73,6 +83,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       configuration: {
         numSlicesToPropagate: 10,
         computePointsInsideVolume: false,
+        getTextLines: defaultGetTextLines,
+        statsCalculator: BasicStatsCalculator,
+        showTextBox: false,
       },
     }
   ) {
@@ -120,22 +133,18 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       );
     }
 
-    if (!referencedImageId) {
-      throw new Error('This tool does not work on non-acquisition planes');
-    }
-
-    const startIndex = viewport.getCurrentImageIdIndex();
     const spacingInNormal = csUtils.getSpacingInNormalDirection(
       imageVolume,
       viewPlaneNormal
     );
 
+    const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+
     // We cannot simply add numSlicesToPropagate to startIndex because
     // the order of imageIds can be from top to bottom or bottom to top and
     // we want to make sure it is always propagated in the direction of the
     // view and also to make sure we don't go out of bounds.
-    const endIndex = this._getEndSliceIndex(
-      imageVolume,
+    const endCoord = this._getEndCoordinate(
       worldPos,
       spacingInNormal,
       viewPlaneNormal
@@ -158,19 +167,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       },
       data: {
         label: '',
-        startSlice: startIndex,
-        endSlice: endIndex,
+        startCoordinate: startCoord,
+        endCoordinate: endCoord,
         cachedStats: {
           pointsInVolume: [],
           projectionPoints: [],
           projectionPointsImageIds: [referencedImageId],
+          statistics: [],
         },
         handles: {
-          // No need a textBox
           textBox: {
             hasMoved: false,
-            worldPosition: null,
-            worldBoundingBox: null,
+            worldPosition: <Types.Point3>[0, 0, 0],
+            worldBoundingBox: {
+              topLeft: <Types.Point3>[0, 0, 0],
+              topRight: <Types.Point3>[0, 0, 0],
+              bottomLeft: <Types.Point3>[0, 0, 0],
+              bottomRight: <Types.Point3>[0, 0, 0],
+            },
           },
           points: [
             <Types.Point3>[...worldPos],
@@ -249,7 +263,12 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
 
     if (this.configuration.calculatePointsInsideVolume) {
-      this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+      this._computePointsInsideVolume(
+        annotation,
+        targetId,
+        imageVolume,
+        enabledElement
+      );
     }
 
     triggerAnnotationRenderForViewportIds(
@@ -262,7 +281,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     }
   };
 
-  // Todo: make it work for planes other than acquisition planes
+  //Now works for non-acquisition planes
   _computeProjectionPoints(
     annotation: RectangleROIStartEndThresholdAnnotation,
     imageVolume: Types.IImageVolume
@@ -270,17 +289,11 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     const { data, metadata } = annotation;
     const { viewPlaneNormal, spacingInNormal } = metadata;
     const { imageData } = imageVolume;
-    const { startSlice, endSlice } = data;
+    const { startCoordinate, endCoordinate } = data;
     const { points } = data.handles;
 
     const startIJK = transformWorldToIndex(imageData, points[0]);
-
-    if (startIJK[2] !== startSlice) {
-      throw new Error('Start slice does not match');
-    }
-
-    // substitute the end slice index 2 with startIJK index 2
-    const endIJK = vec3.fromValues(startIJK[0], startIJK[1], endSlice);
+    const endIJK = transformWorldToIndex(imageData, points[0]);
 
     const startWorld = vec3.create();
     imageData.indexToWorldVec3(startIJK, startWorld);
@@ -288,6 +301,23 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     const endWorld = vec3.create();
     imageData.indexToWorldVec3(endIJK, endWorld);
 
+    // substitute the end slice index 2 with startIJK index 2
+
+    if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+      startWorld[2] = startCoordinate;
+      endWorld[2] = endCoordinate;
+    } else if (
+      this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0
+    ) {
+      startWorld[0] = startCoordinate;
+      endWorld[0] = endCoordinate;
+    } else if (
+      this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1
+    ) {
+      startWorld[1] = startCoordinate;
+      endWorld[1] = endCoordinate;
+    }
+
     // distance between start and end slice in the world coordinate
     const distance = vec3.distance(startWorld, endWorld);
 
@@ -298,6 +328,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       newProjectionPoints.push(
         points.map((point) => {
           const newPoint = vec3.create();
+          //@ts-ignore
           vec3.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
           return Array.from(newPoint);
         })
@@ -305,27 +336,54 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     }
 
     data.cachedStats.projectionPoints = newProjectionPoints;
-
-    // Find the imageIds for the projection points
-    const projectionPointsImageIds = [];
-    for (const RectanglePoints of newProjectionPoints) {
-      const imageId = csUtils.getClosestImageId(
-        imageVolume,
-        RectanglePoints[0],
-        viewPlaneNormal
-      );
-      projectionPointsImageIds.push(imageId);
-    }
-
-    data.cachedStats.projectionPointsImageIds = projectionPointsImageIds;
   }
 
-  //This function return all the points inside the ROI for every slices between startSlice and endSlice
-  _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-    const { data } = annotation;
+  //This function return all the points inside the ROI and calculate statistics for every slices between startCoordinate and endCoordinate
+  _computePointsInsideVolume(
+    annotation,
+    targetId,
+    imageVolume,
+    enabledElement
+  ) {
+    const { data, metadata } = annotation;
+    const { viewPlaneNormal, viewUp } = metadata;
+    const { viewport, renderingEngine } = enabledElement;
+
     const projectionPoints = data.cachedStats.projectionPoints;
 
     const pointsInsideVolume: Types.Point3[][] = [[]];
+    const image = this.getTargetIdImage(targetId, renderingEngine);
+
+    const worldPos1 = data.handles.points[0];
+    const worldPos2 = data.handles.points[3];
+
+    const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(
+      viewPlaneNormal,
+      viewUp,
+      worldPos1,
+      worldPos2
+    );
+    const measureInfo = getCalibratedLengthUnitsAndScale(image, data.habdles);
+
+    const area =
+      Math.abs(worldWidth * worldHeight) /
+      (measureInfo.scale * measureInfo.scale);
+
+    const modalityUnitOptions = {
+      isPreScaled: isViewportPreScaled(viewport, targetId),
+
+      isSuvScaled: this.isSuvScaled(
+        viewport,
+        targetId,
+        annotation.metadata.referencedImageId
+      ),
+    };
+
+    const modalityUnit = getModalityUnit(
+      metadata.Modality,
+      annotation.metadata.referencedImageId,
+      modalityUnitOptions
+    );
 
     for (let i = 0; i < projectionPoints.length; i++) {
       // If image does not exists for the targetId, skip. This can be due
@@ -337,9 +395,6 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
 
       const projectionPoint = projectionPoints[i][0];
 
-      const worldPos1 = data.handles.points[0];
-      const worldPos2 = data.handles.points[3];
-
       const { dimensions, imageData } = imageVolume;
 
       const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
@@ -349,15 +404,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         projectionPoint
       );
 
+      const indexOfProjection =
+        this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+
       worldPos1Index[0] = Math.floor(worldPos1Index[0]);
       worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-      worldPos1Index[2] = Math.floor(worldProjectionPointIndex[2]);
+      worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+
+      worldPos1Index[indexOfProjection] =
+        worldProjectionPointIndex[indexOfProjection];
 
       const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
 
       worldPos2Index[0] = Math.floor(worldPos2Index[0]);
       worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-      worldPos2Index[2] = Math.floor(worldProjectionPointIndex[2]);
+      worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+
+      worldPos2Index[indexOfProjection] =
+        worldProjectionPointIndex[indexOfProjection];
 
       // Check if one of the indexes are inside the volume, this then gives us
       // Some area to do stats over.
@@ -382,7 +446,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         const pointsInShape = pointInShapeCallback(
           imageData,
           () => true,
-          null,
+          this.configuration.statsCalculator.statsCallback,
           boundsIJK
         );
 
@@ -390,7 +454,18 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         pointsInsideVolume.push(pointsInShape);
       }
     }
+    const stats = this.configuration.statsCalculator.getStatistics();
     data.cachedStats.pointsInVolume = pointsInsideVolume;
+    data.cachedStats.statistics = {
+      Modality: metadata.Modality,
+      area,
+      mean: stats.mean?.value,
+      stdDev: stats.stdDev?.value,
+      max: stats.max?.value,
+      statsArray: stats.array,
+      areaUnit: measureInfo.areaUnits,
+      modalityUnit,
+    };
   }
 
   _calculateCachedStatsTool(annotation, enabledElement) {
@@ -427,14 +502,16 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
   ): boolean => {
     let renderStatus = false;
     const { viewport } = enabledElement;
-
-    const annotations = getAnnotations(this.getToolName(), viewport.element);
+    let annotations = getAnnotations(this.getToolName(), viewport.element);
 
     if (!annotations?.length) {
       return renderStatus;
     }
 
-    const sliceIndex = viewport.getCurrentImageIdIndex();
+    annotations = filterAnnotationsWithinSamePlane(
+      annotations,
+      viewport.getCamera()
+    );
 
     const styleSpecifier: StyleSpecifier = {
       toolGroupId: this.toolGroupId,
@@ -447,7 +524,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         i
       ] as RectangleROIStartEndThresholdAnnotation;
       const { annotationUID, data } = annotation;
-      const { startSlice, endSlice } = data;
+      const { startCoordinate, endCoordinate } = data;
       const { points, activeHandleIndex } = data.handles;
 
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
@@ -460,10 +537,37 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       // range of slices to render based on the start and end slice, like
       // np.arange
 
-      // if indexIJK is outside the start/end slice, we don't render
+      const focalPoint = viewport.getCamera().focalPoint;
+      const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+
+      let startCoord: number | vec3 = startCoordinate;
+      let endCoord: number | vec3 = endCoordinate;
+      if (Array.isArray(startCoordinate)) {
+        startCoord = this._getCoordinateForViewplaneNormal(
+          startCoord,
+          viewplaneNormal
+        );
+      }
+
+      if (Array.isArray(endCoordinate)) {
+        endCoord = this._getCoordinateForViewplaneNormal(
+          endCoord,
+          viewplaneNormal
+        );
+      }
+
+      const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
+      const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
+
+      const coord = this._getCoordinateForViewplaneNormal(
+        focalPoint,
+        viewplaneNormal
+      );
+      const roundedCoord = coreUtils.roundToPrecision(coord);
+      // if the focalpoint is outside the start/end coordinates, we don't render
       if (
-        sliceIndex < Math.min(startSlice, endSlice) ||
-        sliceIndex > Math.max(startSlice, endSlice)
+        roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+        roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)
       ) {
         continue;
       }
@@ -477,7 +581,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       // if it is inside the start/end slice, but not exactly the first or
       // last slice, we render the line in dash, but not the handles
       let firstOrLastSlice = false;
-      if (sliceIndex === startSlice || sliceIndex === endSlice) {
+      if (
+        roundedCoord === roundedStartCoord ||
+        roundedCoord === roundedEndCoord
+      ) {
         firstOrLastSlice = true;
       }
 
@@ -538,13 +645,82 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       );
 
       renderStatus = true;
+
+      if (
+        this.configuration.showTextBox &&
+        this.configuration.calculatePointsInsideVolume
+      ) {
+        const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+        if (!options.visibility) {
+          data.handles.textBox = {
+            hasMoved: false,
+            worldPosition: <Types.Point3>[0, 0, 0],
+            worldBoundingBox: {
+              topLeft: <Types.Point3>[0, 0, 0],
+              topRight: <Types.Point3>[0, 0, 0],
+              bottomLeft: <Types.Point3>[0, 0, 0],
+              bottomRight: <Types.Point3>[0, 0, 0],
+            },
+          };
+          continue;
+        }
+
+        const textLines = this.configuration.getTextLines(data);
+        if (!textLines || textLines.length === 0) {
+          continue;
+        }
+
+        if (!data.handles.textBox.hasMoved) {
+          const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
+
+          data.handles.textBox.worldPosition =
+            viewport.canvasToWorld(canvasTextBoxCoords);
+        }
+
+        const textBoxPosition = viewport.worldToCanvas(
+          data.handles.textBox.worldPosition
+        );
+
+        const textBoxUID = '1';
+        const boundingBox = drawLinkedTextBoxSvg(
+          svgDrawingHelper,
+          annotationUID,
+          textBoxUID,
+          textLines,
+          textBoxPosition,
+          canvasCoordinates,
+          {},
+          options
+        );
+
+        const { x: left, y: top, width, height } = boundingBox;
+
+        data.handles.textBox.worldBoundingBox = {
+          topLeft: viewport.canvasToWorld([left, top]),
+          topRight: viewport.canvasToWorld([left + width, top]),
+          bottomLeft: viewport.canvasToWorld([left, top + height]),
+          bottomRight: viewport.canvasToWorld([left + width, top + height]),
+        };
+      }
     }
 
     return renderStatus;
   };
 
-  _getEndSliceIndex(
-    imageVolume: Types.IImageVolume,
+  _getStartCoordinate(
+    worldPos: Types.Point3,
+    viewPlaneNormal: Types.Point3
+  ): number | undefined {
+    const startPos = worldPos;
+    const startCoord = this._getCoordinateForViewplaneNormal(
+      startPos,
+      viewPlaneNormal
+    );
+
+    return startCoord;
+  }
+
+  _getEndCoordinate(
     worldPos: Types.Point3,
     spacingInNormal: number,
     viewPlaneNormal: Types.Point3
@@ -561,31 +737,65 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
       numSlicesToPropagate * spacingInNormal
     );
 
-    const halfSpacingInNormalDirection = spacingInNormal / 2;
-    // Loop through imageIds of the imageVolume and find the one that is closest to endPos
-    const { imageIds } = imageVolume;
-    let imageIdIndex;
-    for (let i = 0; i < imageIds.length; i++) {
-      const imageId = imageIds[i];
+    const endCoord = this._getCoordinateForViewplaneNormal(
+      endPos,
+      viewPlaneNormal
+    );
 
-      const { imagePositionPatient } = metaData.get(
-        'imagePlaneModule',
-        imageId
-      );
+    return endCoord;
+  }
 
-      const dir = vec3.create();
-      vec3.sub(dir, endPos, imagePositionPatient);
+  _getIndexOfCoordinatesForViewplaneNormal(
+    viewPlaneNormal: Types.Point3
+  ): number {
+    const viewplaneNormalAbs = [
+      Math.abs(viewPlaneNormal[0]),
+      Math.abs(viewPlaneNormal[1]),
+      Math.abs(viewPlaneNormal[2]),
+    ];
+    const indexOfDirection = viewplaneNormalAbs.indexOf(
+      Math.max(...viewplaneNormalAbs)
+    );
 
-      const dot = vec3.dot(dir, viewPlaneNormal);
+    return indexOfDirection;
+  }
 
-      if (Math.abs(dot) < halfSpacingInNormalDirection) {
-        imageIdIndex = i;
-      }
-    }
+  _getCoordinateForViewplaneNormal(
+    pos: vec3 | number,
+    viewPlaneNormal: Types.Point3
+  ): number | undefined {
+    const indexOfDirection =
+      this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
 
-    return imageIdIndex;
+    return pos[indexOfDirection];
   }
 }
 
+/**
+ * _getTextLines - Returns the Area, mean and std deviation of the area of the
+ * target volume enclosed by the rectangle.
+ *
+ * @param data - The annotation tool-specific data.
+ * @param targetId - The volumeId of the volume to display the stats for.
+ */
+function defaultGetTextLines(data): string[] {
+  const cachedVolumeStats = data.cachedStats.statistics;
+
+  const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+
+  if (mean === undefined) {
+    return;
+  }
+
+  const textLines: string[] = [];
+
+  textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
+  textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+  textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+  textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+
+  return textLines;
+}
+
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 export default RectangleROIStartEndThresholdTool;

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -240,16 +240,27 @@ export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
   };
   data: {
     label: string;
-    startSlice: number;
-    endSlice: number;
+    startCoordinate: number;
+    endCoordinate: number;
     cachedStats: {
       pointsInVolume: Types.Point3[];
       projectionPoints: Types.Point3[][]; // first slice p1, p2, p3, p4; second slice p1, p2, p3, p4 ...
       projectionPointsImageIds: string[];
+      statistics?: ROICachedStats | any[];
     };
     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;
+        };
+      };
     };
   };
 }
@@ -270,15 +281,26 @@ export interface CircleROIStartEndThresholdAnnotation extends Annotation {
   };
   data: {
     label: string;
-    startSlice: number;
-    endSlice: number;
+    startCoordinate: number;
+    endCoordinate: number;
     cachedStats?: {
       pointsInVolume: Types.Point3[];
       projectionPoints: Types.Point3[][];
+      statistics?: ROICachedStats | any[];
     };
     handles: {
       points: [Types.Point3, Types.Point3]; // [center, end]
       activeHandleIndex: number | null;
+      textBox?: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
     };
   };
 }