@cornerstonejs/tools 0.61.5 → 0.61.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "0.61.5",
+  "version": "0.61.7",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9301f3dd164dbd88664a0e1961f686234fe29919"
+  "gitHead": "0bb66c6cb814db95508e50cca647e71ae6e7e7b7"
 }

package/src/tools/CrosshairsTool.ts

@@ -1464,79 +1464,50 @@ class CrosshairsTool extends AnnotationTool {
     viewportId: string,
     renderingEngine: Types.IRenderingEngine
   ): void {
-    // 1. Compute the current world bounding box of the viewport from corner to corner
-    // 2. Check if the toolCenter is outside of the world bounding box
-    // 3. If it is outside, pan the viewport to fit in the toolCenter
+    // 1. Check if the toolCenter is outside the viewport
+    // 2. If it is outside, pan the viewport to fit in the toolCenter
 
     const viewport = renderingEngine.getViewport(viewportId);
     const { clientWidth, clientHeight } = viewport.canvas;
-    const topLefWorld = viewport.canvasToWorld([0, 0]);
-    const bottomRightWorld = viewport.canvasToWorld([
-      clientWidth,
-      clientHeight,
-    ]);
-    const topRightWorld = viewport.canvasToWorld([clientWidth, 0]);
-    const bottomLeftWorld = viewport.canvasToWorld([0, clientHeight]);
-
-    // find the minimum and maximum world coordinates in each x,y,z
-    const minX = Math.min(
-      topLefWorld[0],
-      bottomRightWorld[0],
-      topRightWorld[0],
-      bottomLeftWorld[0]
-    );
-    const maxX = Math.max(
-      topLefWorld[0],
-      bottomRightWorld[0],
-      topRightWorld[0],
-      bottomLeftWorld[0]
-    );
-    const minY = Math.min(
-      topLefWorld[1],
-      bottomRightWorld[1],
-      topRightWorld[1],
-      bottomLeftWorld[1]
-    );
-    const maxY = Math.max(
-      topLefWorld[1],
-      bottomRightWorld[1],
-      topRightWorld[1],
-      bottomLeftWorld[1]
-    );
-    const minZ = Math.min(
-      topLefWorld[2],
-      bottomRightWorld[2],
-      topRightWorld[2],
-      bottomLeftWorld[2]
-    );
-    const maxZ = Math.max(
-      topLefWorld[2],
-      bottomRightWorld[2],
-      topRightWorld[2],
-      bottomLeftWorld[2]
-    );
+
+    const toolCenterCanvas = viewport.worldToCanvas(this.toolCenter);
 
     // pan the viewport to fit the toolCenter in the direction
     // that is out of bounds
-    let deltaPointsWorld;
     const pan = this.configuration.autoPan.panSize;
 
-    if (this.toolCenter[0] < minX - EPSILON) {
-      deltaPointsWorld = [minX - this.toolCenter[0] + pan, 0, 0];
-    } else if (this.toolCenter[0] > maxX + EPSILON) {
-      deltaPointsWorld = [maxX - this.toolCenter[0] - pan, 0, 0];
-    } else if (this.toolCenter[1] < minY - EPSILON) {
-      deltaPointsWorld = [0, minY - this.toolCenter[1] + pan, 0];
-    } else if (this.toolCenter[1] > maxY + EPSILON) {
-      deltaPointsWorld = [0, maxY - this.toolCenter[1] - pan, 0];
-    } else if (this.toolCenter[2] < minZ - EPSILON) {
-      deltaPointsWorld = [0, 0, minZ - this.toolCenter[2] + pan];
-    } else if (this.toolCenter[2] > maxZ + EPSILON) {
-      deltaPointsWorld = [0, 0, maxZ - this.toolCenter[2] - pan];
-    } else {
+    const visiblePointCanvas = <Types.Point2>[
+      toolCenterCanvas[0],
+      toolCenterCanvas[1],
+    ];
+
+    if (toolCenterCanvas[0] < 0) {
+      visiblePointCanvas[0] = pan;
+    } else if (toolCenterCanvas[0] > clientWidth) {
+      visiblePointCanvas[0] = clientWidth - pan;
+    }
+
+    if (toolCenterCanvas[1] < 0) {
+      visiblePointCanvas[1] = pan;
+    } else if (toolCenterCanvas[1] > clientHeight) {
+      visiblePointCanvas[1] = clientHeight - pan;
+    }
+
+    if (
+      visiblePointCanvas[0] === toolCenterCanvas[0] &&
+      visiblePointCanvas[1] === toolCenterCanvas[1]
+    ) {
       return;
     }
 
+    const visiblePointWorld = viewport.canvasToWorld(visiblePointCanvas);
+
+    const deltaPointsWorld = [
+      visiblePointWorld[0] - this.toolCenter[0],
+      visiblePointWorld[1] - this.toolCenter[1],
+      visiblePointWorld[2] - this.toolCenter[2],
+    ];
+
     const camera = viewport.getCamera();
     const { focalPoint, position } = camera;
 

package/src/tools/displayTools/Labelmap/labelmapDisplay.ts

@@ -134,6 +134,40 @@ function removeSegmentationRepresentation(
   }
 }
 
+/**
+ * Checks if a segmentation data have the same frameOfReference as the series
+ * displayed in a given viewport
+ * @param viewport
+ * @param referencedVolumeId volume id of the segmentation reference series
+ * @returns
+ */
+function isSameFrameOfReference(viewport, referencedVolumeId) {
+  // if the referencedVolumeId is not defined, we acted as before to not break
+  // applications as referencedVolumeId is inserted in this change
+  // Can modify that in the future commits
+  if (!referencedVolumeId) {
+    return true;
+  }
+  const defaultActor = viewport.getDefaultActor();
+  if (!defaultActor) {
+    return false;
+  }
+  const { uid: defaultActorUID } = defaultActor;
+  const volume = cache.getVolume(defaultActorUID);
+
+  if (volume) {
+    const referencedVolume = cache.getVolume(referencedVolumeId);
+    if (
+      referencedVolume &&
+      volume.metadata.FrameOfReferenceUID ===
+        referencedVolume.metadata.FrameOfReferenceUID
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /**
  * It takes the enabled element, the segmentation Id, and the configuration, and
  * it sets the segmentation for the enabled element as a labelmap
@@ -166,6 +200,9 @@ async function render(
     throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
   }
 
+  if (!isSameFrameOfReference(viewport, labelmapData?.referencedVolumeId)) {
+    return;
+  }
   let actorEntry = viewport.getActor(segmentationRepresentationUID);
 
   if (!actorEntry) {
@@ -182,6 +219,10 @@ async function render(
     actorEntry = viewport.getActor(segmentationRepresentationUID);
   }
 
+  if (!actorEntry) {
+    return;
+  }
+
   const { cfun, ofun } = renderingConfig as LabelmapRenderingConfig;
 
   const renderInactiveSegmentations =