@cornerstonejs/tools 1.43.5 → 1.43.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.43.5",
+  "version": "1.43.7",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.43.5",
+    "@cornerstonejs/core": "^1.43.7",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b63236689d4dc65ccfa11ba34a516991d17e726c"
+  "gitHead": "2d0c559929aa0524bf303922230ded50ac0ef1df"
 }

package/src/stateManagement/annotation/annotationState.ts

@@ -80,18 +80,18 @@ function addAnnotation(
   }
 
   const manager = getAnnotationManager();
-  const groupKey = manager.getGroupKey(annotationGroupSelector);
-
-  manager.addAnnotation(annotation, groupKey);
 
   // if the annotation manager selector is an element, trigger the
   // annotation added event for that element.
   if (annotationGroupSelector instanceof HTMLDivElement) {
+    const groupKey = manager.getGroupKey(annotationGroupSelector);
+    manager.addAnnotation(annotation, groupKey);
     triggerAnnotationAddedForElement(annotation, annotationGroupSelector);
   } else {
     // if no element is provided, render all viewports that have the
     // same frame of reference.
     // Todo: we should do something else here for other types of annotation managers.
+    manager.addAnnotation(annotation);
     triggerAnnotationAddedForFOR(annotation);
   }
 

package/src/stateManagement/annotation/helpers/state.ts

@@ -41,14 +41,12 @@ function triggerAnnotationAddedForFOR(annotation: Annotation) {
   const { toolName } = annotation.metadata;
 
   const toolGroups = getToolGroupsWithToolName(toolName);
-
   if (!toolGroups.length) {
     return;
   }
 
   // Find the viewports in the toolGroups who has the same FrameOfReferenceUID
   const viewportsToRender = [];
-
   toolGroups.forEach((toolGroup) => {
     toolGroup.viewportsInfo.forEach((viewportInfo) => {
       const { renderingEngineId, viewportId } = viewportInfo;
@@ -63,19 +61,17 @@ function triggerAnnotationAddedForFOR(annotation: Annotation) {
     });
   });
 
+  const eventType = Events.ANNOTATION_ADDED;
+  const eventDetail: AnnotationAddedEventDetail = { annotation };
+
   if (!viewportsToRender.length) {
+    triggerEvent(eventTarget, eventType, eventDetail);
     return;
   }
 
-  const eventType = Events.ANNOTATION_ADDED;
-
   viewportsToRender.forEach(({ renderingEngineId, viewportId }) => {
-    const eventDetail: AnnotationAddedEventDetail = {
-      annotation,
-      viewportId,
-      renderingEngineId,
-    };
-
+    eventDetail.viewportId = viewportId;
+    eventDetail.renderingEngineId = renderingEngineId;
     triggerEvent(eventTarget, eventType, eventDetail);
   });
 }

package/src/types/EventTypes.ts

@@ -104,9 +104,9 @@ type ToolActivatedEventDetail = {
  */
 type AnnotationAddedEventDetail = {
   /** unique id of the viewport */
-  viewportId: string;
+  viewportId?: string;
   /** unique id of the rendering engine */
-  renderingEngineId: string;
+  renderingEngineId?: string;
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
 };

package/src/utilities/pointInSurroundingSphereCallback.ts

@@ -0,0 +1,188 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { vec3 } from 'gl-matrix';
+import { pointInSphere } from './math/sphere';
+import pointInShapeCallback, {
+  PointInShapeCallback,
+} from './pointInShapeCallback';
+import { BoundsIJK } from '../types';
+import { getBoundingBoxAroundShape } from './boundingBox';
+
+const { transformWorldToIndex } = csUtils;
+
+/**
+ * Given an imageData, and the great circle top and bottom points of a sphere,
+ * this function will run the callback for each point of the imageData that is
+ * within the sphere defined by the great circle points. If the viewport
+ * is provided, region of interest will be an accurate approximation of the
+ * sphere (using viewport camera), and the resulting performance will be
+ * better.
+ *
+ * @privateRemarks great circle also known as orthodrome is the intersection of
+ * the sphere and the plane that passes through the center of the sphere
+ *
+ * @param imageData - The volume imageData
+ * @param circlePoints - bottom and top points of the great circle in world coordinates
+ * @param callback - A callback function that will be called for each point in the shape.
+ */
+export default function pointInSurroundingSphereCallback(
+  imageData: vtkImageData,
+  circlePoints: [Types.Point3, Types.Point3],
+  callback: PointInShapeCallback,
+  viewport?: Types.IVolumeViewport
+): void {
+  // We can run the sphere equation to determine if a point is inside
+  // the sphere; however, since the imageData dimensions can be quite large, we
+  // can narrow down the search by estimating the bounds of the sphere in index
+  // space.
+  const { boundsIJK, centerWorld, radiusWorld } = _getBounds(
+    circlePoints,
+    imageData,
+    viewport
+  );
+
+  const sphereObj = {
+    center: centerWorld,
+    radius: radiusWorld,
+  };
+
+  pointInShapeCallback(
+    imageData,
+    (pointLPS) => pointInSphere(sphereObj, pointLPS),
+    callback,
+    boundsIJK
+  );
+}
+
+function _getBounds(
+  circlePoints: [Types.Point3, Types.Point3],
+  imageData: vtkImageData,
+  viewport
+): {
+  boundsIJK: BoundsIJK;
+  centerWorld: Types.Point3;
+  radiusWorld: number;
+} {
+  const [bottom, top] = circlePoints;
+
+  // Sphere center in world
+  const centerWorld = vec3.fromValues(
+    (bottom[0] + top[0]) / 2,
+    (bottom[1] + top[1]) / 2,
+    (bottom[2] + top[2]) / 2
+  );
+
+  // sphere radius in world
+  const radiusWorld = vec3.distance(bottom, top) / 2;
+
+  let boundsIJK;
+
+  if (!viewport) {
+    // If no viewport is provide (no camera), we can estimate the bounding box
+    // of the sphere in index space.
+    // This is done by calculating the maximum value for radius in the index
+    // space (since the radius is in world space, we need to convert it to index, and
+    // each dimensions can have a different scale factor). Therefore, by finding
+    // the minimum spacing value in the imageData, we can calculate the maximum
+    // radius in index space and use that to calculate the bounds of the sphere
+    // This will not be accurate, but it is a good first approximation.
+    // sphere center in index
+    const centerIJK = transformWorldToIndex(
+      imageData,
+      centerWorld as Types.Point3
+    );
+
+    const spacings = imageData.getSpacing();
+    const minSpacing = Math.min(...spacings);
+
+    const maxRadiusIJK = Math.ceil(radiusWorld / minSpacing);
+
+    boundsIJK = [
+      [centerIJK[0] - maxRadiusIJK, centerIJK[0] + maxRadiusIJK],
+      [centerIJK[1] - maxRadiusIJK, centerIJK[1] + maxRadiusIJK],
+      [centerIJK[2] - maxRadiusIJK, centerIJK[2] + maxRadiusIJK],
+    ];
+
+    return {
+      boundsIJK,
+      centerWorld: centerWorld as Types.Point3,
+      radiusWorld,
+    };
+  }
+
+  boundsIJK = _computeBoundsIJKWithCamera(
+    imageData,
+    viewport,
+    circlePoints,
+    centerWorld,
+    radiusWorld
+  );
+
+  return {
+    boundsIJK,
+    centerWorld: centerWorld as Types.Point3,
+    radiusWorld,
+  };
+}
+
+function _computeBoundsIJKWithCamera(
+  imageData,
+  viewport,
+  circlePoints,
+  centerWorld,
+  radiusWorld
+) {
+  const [bottom, top] = circlePoints;
+
+  const dimensions = imageData.getDimensions() as Types.Point3;
+  const camera = viewport.getCamera();
+
+  // Calculate viewRight from the camera, this will get used in order to
+  // calculate circles topLeft and bottomRight on different planes of intersection
+  // between sphere and viewPlane
+  const viewUp = vec3.fromValues(
+    camera.viewUp[0],
+    camera.viewUp[1],
+    camera.viewUp[2]
+  );
+  const viewPlaneNormal = vec3.fromValues(
+    camera.viewPlaneNormal[0],
+    camera.viewPlaneNormal[1],
+    camera.viewPlaneNormal[2]
+  );
+  const viewRight = vec3.create();
+
+  vec3.cross(viewRight, viewUp, viewPlaneNormal);
+
+  // we need to find the bounding box of the sphere in the image, e.g., the
+  // topLeftWorld and bottomRightWorld points of the bounding box.
+  // We go from the sphereCenter in the normal direction of amount radius, and
+  // we go left to find the topLeftWorld point of the bounding box. Next we go
+  // in the opposite direction and go right to find the bottomRightWorld point
+  // of the bounding box.
+  const topLeftWorld = vec3.create();
+  const bottomRightWorld = vec3.create();
+
+  vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
+  vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
+
+  // go in the direction of viewRight with the value of radius
+  vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
+  vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+
+  // convert the world coordinates to index coordinates
+
+  const sphereCornersIJK = [
+    <Types.Point3>transformWorldToIndex(imageData, <Types.Point3>topLeftWorld),
+    <Types.Point3>(
+      transformWorldToIndex(imageData, <Types.Point3>bottomRightWorld)
+    ),
+  ];
+
+  // get the bounding box of the sphere in the image
+  const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
+
+  return boundsIJK;
+}