@cornerstonejs/tools 1.61.7 → 1.63.0

package/src/tools/segmentation/RectangleROIStartEndThresholdTool.ts

@@ -8,7 +8,11 @@ import {
 import type { Types } from '@cornerstonejs/core';
 
 import { vec3 } from 'gl-matrix';
-import { addAnnotation, getAnnotations } from '../../stateManagement';
+import {
+  addAnnotation,
+  getAnnotations,
+  removeAnnotation,
+} from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import {
@@ -18,8 +22,12 @@ import {
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
-import { hideElementCursor } from '../../cursors/elementCursor';
+import {
+  hideElementCursor,
+  resetElementCursor,
+} from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { triggerAnnotationCompleted } from '../../stateManagement/annotation/helpers/state';
 
 import {
   PublicToolProps,
@@ -30,6 +38,7 @@ import {
 import { RectangleROIStartEndThresholdAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import RectangleROITool from '../annotation/RectangleROITool';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
+import { pointInShapeCallback } from '../../utilities/';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -63,6 +72,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     defaultToolProps: ToolProps = {
       configuration: {
         numSlicesToPropagate: 10,
+        computePointsInsideVolume: false,
       },
     }
   ) {
@@ -151,6 +161,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         startSlice: startIndex,
         endSlice: endIndex,
         cachedStats: {
+          pointsInVolume: [],
           projectionPoints: [],
           projectionPointsImageIds: [referencedImageId],
         },
@@ -203,6 +214,54 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     return annotation;
   };
 
+  _endCallback = (evt: EventTypes.InteractionEventType): void => {
+    const eventDetail = evt.detail;
+    const { element } = eventDetail;
+
+    const { annotation, viewportIdsToRender, newAnnotation, hasMoved } =
+      this.editData;
+    const { data } = annotation;
+
+    if (newAnnotation && !hasMoved) {
+      return;
+    }
+
+    data.handles.activeHandleIndex = null;
+
+    this._deactivateModify(element);
+    this._deactivateDraw(element);
+
+    resetElementCursor(element);
+
+    const enabledElement = getEnabledElement(element);
+
+    this.editData = null;
+    this.isDrawing = false;
+
+    if (
+      this.isHandleOutsideImage &&
+      this.configuration.preventHandleOutsideImage
+    ) {
+      removeAnnotation(annotation.annotationUID);
+    }
+
+    const targetId = this.getTargetId(enabledElement.viewport);
+    const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
+
+    if (this.configuration.calculatePointsInsideVolume) {
+      this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+    }
+
+    triggerAnnotationRenderForViewportIds(
+      enabledElement.renderingEngine,
+      viewportIdsToRender
+    );
+
+    if (newAnnotation) {
+      triggerAnnotationCompleted(annotation);
+    }
+  };
+
   // Todo: make it work for planes other than acquisition planes
   _computeProjectionPoints(
     annotation: RectangleROIStartEndThresholdAnnotation,
@@ -261,6 +320,79 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     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;
+    const projectionPoints = data.cachedStats.projectionPoints;
+
+    const pointsInsideVolume: Types.Point3[][] = [[]];
+
+    for (let i = 0; i < projectionPoints.length; i++) {
+      // If image does not exists for the targetId, skip. This can be due
+      // to various reasons such as if the target was a volumeViewport, and
+      // the volumeViewport has been decached in the meantime.
+      if (!imageVolume) {
+        continue;
+      }
+
+      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);
+      //We only need to change the Z of our bounds so we are getting the Z from the current projection point
+      const worldProjectionPointIndex = transformWorldToIndex(
+        imageData,
+        projectionPoint
+      );
+
+      worldPos1Index[0] = Math.floor(worldPos1Index[0]);
+      worldPos1Index[1] = Math.floor(worldPos1Index[1]);
+      worldPos1Index[2] = Math.floor(worldProjectionPointIndex[2]);
+
+      const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
+
+      worldPos2Index[0] = Math.floor(worldPos2Index[0]);
+      worldPos2Index[1] = Math.floor(worldPos2Index[1]);
+      worldPos2Index[2] = Math.floor(worldProjectionPointIndex[2]);
+
+      // Check if one of the indexes are inside the volume, this then gives us
+      // Some area to do stats over.
+
+      if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
+        this.isHandleOutsideImage = false;
+        const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
+        const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
+
+        const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);
+        const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
+
+        const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
+        const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
+
+        const boundsIJK = [
+          [iMin, iMax],
+          [jMin, jMax],
+          [kMin, kMax],
+        ] as [Types.Point2, Types.Point2, Types.Point2];
+
+        const pointsInShape = pointInShapeCallback(
+          imageData,
+          () => true,
+          null,
+          boundsIJK
+        );
+
+        //@ts-ignore
+        pointsInsideVolume.push(pointsInShape);
+      }
+    }
+    data.cachedStats.pointsInVolume = pointsInsideVolume;
+  }
+
   _calculateCachedStatsTool(annotation, enabledElement) {
     const data = annotation.data;
     const { element, viewport } = enabledElement;

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -35,6 +35,7 @@ export interface RectangleROIAnnotation extends Annotation {
     cachedStats?:
       | ROICachedStats
       | {
+          pointsInVolume?: Types.Point3[];
           projectionPoints?: Types.Point3[];
           projectionPointsImageIds?: string[];
         };
@@ -110,13 +111,18 @@ export interface CircleROIAnnotation extends Annotation {
       };
     };
     label: string;
-    cachedStats?: ROICachedStats & {
-      [targetId: string]: {
-        radius: number;
-        radiusUnit: string;
-        perimeter: number;
-      };
-    };
+    cachedStats?:
+      | (ROICachedStats & {
+          [targetId: string]: {
+            radius: number;
+            radiusUnit: string;
+            perimeter: number;
+          };
+        })
+      | {
+          pointsInVolume: Types.Point3[];
+          projectionPoints: Types.Point3[][];
+        };
   };
 }
 
@@ -236,6 +242,7 @@ export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
     startSlice: number;
     endSlice: number;
     cachedStats: {
+      pointsInVolume: Types.Point3[];
       projectionPoints: Types.Point3[][]; // first slice p1, p2, p3, p4; second slice p1, p2, p3, p4 ...
       projectionPointsImageIds: string[];
     };
@@ -246,6 +253,35 @@ export interface RectangleROIStartEndThresholdAnnotation extends Annotation {
   };
 }
 
+export interface CircleROIStartEndThresholdAnnotation extends Annotation {
+  metadata: {
+    cameraPosition?: Types.Point3;
+    cameraFocalPoint?: Types.Point3;
+    viewPlaneNormal?: Types.Point3;
+    viewUp?: Types.Point3;
+    annotationUID?: string;
+    FrameOfReferenceUID: string;
+    referencedImageId?: string;
+    toolName: string;
+    enabledElement: any; // Todo: how to remove this from the annotation??
+    volumeId: string;
+    spacingInNormal: number;
+  };
+  data: {
+    label: string;
+    startSlice: number;
+    endSlice: number;
+    cachedStats?: {
+      pointsInVolume: Types.Point3[];
+      projectionPoints: Types.Point3[][];
+    };
+    handles: {
+      points: [Types.Point3, Types.Point3]; // [center, end]
+      activeHandleIndex: number | null;
+    };
+  };
+}
+
 export type PlanarFreehandROIAnnotation = ContourAnnotation & {
   data: {
     label?: string;
@@ -256,7 +292,6 @@ export type PlanarFreehandROIAnnotation = ContourAnnotation & {
     cachedStats?: ROICachedStats;
   };
 };
-
 export type PlanarFreehandContourSegmentationAnnotation =
   PlanarFreehandROIAnnotation & ContourSegmentationAnnotationData;