@cornerstonejs/tools 1.78.3 → 1.80.0

package/src/utilities/planar/filterAnnotationsWithinPlane.ts

@@ -0,0 +1,76 @@
+import { vec3 } from 'gl-matrix';
+import { CONSTANTS, metaData } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { Annotations, Annotation } from '../../types';
+
+const { EPSILON } = CONSTANTS;
+
+const PARALLEL_THRESHOLD = 1 - EPSILON;
+
+/**
+ * given some `Annotations`, and the slice defined by the camera's normal
+ * direction and the spacing in the normal, filter the `Annotations` which
+ * is within the slice.
+ *
+ * @param annotations - Annotations
+ * @param camera - The camera
+ * @param spacingInNormalDirection - The spacing in the normal direction
+ * @returns The filtered `Annotations`.
+ */
+export function filterAnnotationsWithinSamePlane(
+  annotations: Annotations,
+  camera: Types.ICamera
+): Annotations {
+  const { viewPlaneNormal } = camera;
+
+  // The reason we use parallel normals instead of actual orientation is that
+  // flipped action is done through camera API, so we can't rely on the
+  // orientation (viewplaneNormal and viewUp) since even the same image and
+  // same slice if flipped will have different orientation, but still rendering
+  // the same slice. Instead, we choose to use the parallel normals to filter
+  // the annotations and later we fine tune it with the annotation within slice
+  // logic down below.
+  const annotationsWithParallelNormals = annotations.filter(
+    (td: Annotation) => {
+      let annotationViewPlaneNormal = td.metadata.viewPlaneNormal;
+
+      if (!annotationViewPlaneNormal) {
+        // This code is run to set the annotation view plane normal
+        // for historical data which was saved without the normal.
+        const { referencedImageId } = td.metadata;
+        const { imageOrientationPatient } = metaData.get(
+          'imagePlaneModule',
+          referencedImageId
+        );
+        const rowCosineVec = vec3.fromValues(
+          imageOrientationPatient[0],
+          imageOrientationPatient[1],
+          imageOrientationPatient[2]
+        );
+
+        const colCosineVec = vec3.fromValues(
+          imageOrientationPatient[3],
+          imageOrientationPatient[4],
+          imageOrientationPatient[5]
+        );
+
+        annotationViewPlaneNormal = vec3.create() as Types.Point3;
+
+        vec3.cross(annotationViewPlaneNormal, rowCosineVec, colCosineVec);
+        td.metadata.viewPlaneNormal = annotationViewPlaneNormal;
+      }
+      const isParallel =
+        Math.abs(vec3.dot(viewPlaneNormal, annotationViewPlaneNormal)) >
+        PARALLEL_THRESHOLD;
+
+      return annotationViewPlaneNormal && isParallel;
+    }
+  );
+
+  // No in plane annotations.
+  if (!annotationsWithParallelNormals.length) {
+    return [];
+  }
+
+  return annotationsWithParallelNormals;
+}

package/src/utilities/planar/index.ts

@@ -3,6 +3,7 @@ import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorne
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
 import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
 import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 
 export default {
   filterAnnotationsWithinSlice,
@@ -10,6 +11,7 @@ export default {
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
   isPlaneIntersectingAABB,
+  filterAnnotationsWithinSamePlane,
 };
 
 export {
@@ -18,4 +20,5 @@ export {
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
   isPlaneIntersectingAABB,
+  filterAnnotationsWithinSamePlane,
 };

package/src/utilities/viewport/isViewportPreScaled.ts

@@ -3,6 +3,7 @@ import {
   StackViewport,
   Types,
   BaseVolumeViewport,
+  utilities,
 } from '@cornerstonejs/core';
 
 function isViewportPreScaled(
@@ -10,11 +11,7 @@ function isViewportPreScaled(
   targetId: string
 ): boolean {
   if (viewport instanceof BaseVolumeViewport) {
-    const targetIdTokens = targetId.split('volumeId:');
-    const volumeId =
-      targetIdTokens.length > 1
-        ? targetIdTokens[1].split('?')[0]
-        : targetIdTokens[0];
+    const volumeId = utilities.getVolumeId(targetId);
     const volume = cache.getVolume(volumeId);
     return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
   } else if (viewport instanceof StackViewport) {