@cornerstonejs/core 2.0.0-beta.1 → 2.0.0-beta.3

package/src/utilities/calculateViewportsSpatialRegistration.ts

@@ -1,9 +1,15 @@
 import { vec3, mat4 } from 'gl-matrix';
 import { IStackViewport } from '../types';
-import { StackViewport } from '../RenderingEngine';
 import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
 import { metaData } from '..';
-import isEqual from './isEqual';
+
+/**
+ * Defines the allowed difference as a percent between the unit normals before
+ * two planes are considered not coplanar.  Since this value is small compared
+ * to the unit lenght, this value is approximately the angular difference, measured
+ * in radians.  That is, allow about a 3 degrees variation.
+ */
+const ALLOWED_DELTA = 0.05;
 
 /**
  * It calculates the registration matrix between two viewports (currently only
@@ -21,40 +27,28 @@ function calculateViewportsSpatialRegistration(
   viewport1: IStackViewport,
   viewport2: IStackViewport
 ): void {
-  if (
-    !(viewport1 instanceof StackViewport) ||
-    !(viewport2 instanceof StackViewport)
-  ) {
-    throw new Error(
-      'calculateViewportsSpatialRegistration: Both viewports must be StackViewports, volume viewports are not supported yet'
-    );
-  }
-
-  const isSameFrameOfReference =
-    viewport1.getFrameOfReferenceUID() === viewport2.getFrameOfReferenceUID();
-
-  if (isSameFrameOfReference) {
-    return;
-  }
-
   const imageId1 = viewport1.getCurrentImageId();
   const imageId2 = viewport2.getCurrentImageId();
 
   const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
   const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
 
-  const isSameImagePlane =
-    imagePlaneModule1 &&
-    imagePlaneModule2 &&
-    isEqual(
-      imagePlaneModule1.imageOrientationPatient,
-      imagePlaneModule2.imageOrientationPatient
-    );
+  if (!imagePlaneModule1 || !imagePlaneModule2) {
+    console.log('Viewport spatial registration requires image plane module');
+    return;
+  }
+  const { imageOrientationPatient: iop2 } = imagePlaneModule2;
+  const isSameImagePlane = imagePlaneModule1.imageOrientationPatient.every(
+    (v, i) => Math.abs(v - iop2[i]) < ALLOWED_DELTA
+  );
 
   if (!isSameImagePlane) {
-    throw new Error(
-      'Viewport spatial registration only supported for same orientation (hence translation only) for now'
+    console.log(
+      'Viewport spatial registration only supported for same orientation (hence translation only) for now',
+      imagePlaneModule1?.imageOrientationPatient,
+      imagePlaneModule2?.imageOrientationPatient
     );
+    return;
   }
 
   const imagePositionPatient1 = imagePlaneModule1.imagePositionPatient;
@@ -67,7 +61,6 @@ function calculateViewportsSpatialRegistration(
   );
 
   const mat = mat4.fromTranslation(mat4.create(), translation);
-
   spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
 }
 

package/src/utilities/getClosestStackImageIndexForPoint.ts

@@ -29,11 +29,15 @@ export function calculateMinimalDistanceForStackViewport(
   const imageIds = viewport.getImageIds();
   const currentImageIdIndex = viewport.getCurrentImageIdIndex();
 
-  if (imageIds.length === 0) return null;
+  if (imageIds.length === 0) {
+    return null;
+  }
 
   const getDistance = (imageId: string): null | number => {
     const planeMetadata = getPlaneMetadata(imageId);
-    if (!planeMetadata) return null;
+    if (!planeMetadata) {
+      return null;
+    }
     const plane = planar.planeEquation(
       planeMetadata.planeNormal,
       planeMetadata.imagePositionPatient
@@ -53,22 +57,30 @@ export function calculateMinimalDistanceForStackViewport(
   for (let i = 0; i < higherImageIds.length; i++) {
     const id = higherImageIds[i];
     const distance = getDistance(id);
-    if (distance === null) continue;
+    if (distance === null) {
+      continue;
+    }
     if (distance <= closestStack.distance) {
       closestStack.distance = distance;
       closestStack.index = i + currentImageIdIndex + 1;
-    } else break;
+    } else {
+      break;
+    }
   }
   //check lower indices
   const lowerImageIds = imageIds.slice(0, currentImageIdIndex);
   for (let i = lowerImageIds.length - 1; i >= 0; i--) {
     const id = lowerImageIds[i];
     const distance = getDistance(id);
-    if (distance === null || distance === closestStack.distance) continue;
+    if (distance === null || distance === closestStack.distance) {
+      continue;
+    }
     if (distance < closestStack.distance) {
       closestStack.distance = distance;
       closestStack.index = i;
-    } else break;
+    } else {
+      break;
+    }
   }
   return closestStack.distance === Infinity ? null : closestStack;
 }

package/src/utilities/getRuntimeId.ts

@@ -46,7 +46,9 @@ function getNextRuntimeId(
       n = n + 1;
     } else {
       n = 0;
-      if (i + 1 === idComponents.length) idComponents.push(0);
+      if (i + 1 === idComponents.length) {
+        idComponents.push(0);
+      }
     }
     idComponents[i] = n;
   }

package/src/utilities/windowLevel.ts

@@ -1,5 +1,8 @@
 /**
  * Given a low and high window level, return the window width and window center
+ * Formulas from note 4 in
+ * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
+ * extended to allow for low/high swapping
  * @param low - The low window level.
  * @param high - The high window level.
  * @returns a JavaScript object with two properties: windowWidth and windowCenter.
@@ -11,14 +14,20 @@ function toWindowLevel(
   windowWidth: number;
   windowCenter: number;
 } {
-  const windowWidth = Math.abs(low - high);
-  const windowCenter = low + windowWidth / 2;
+  // Allow for swapping high/low
+  const windowWidth = Math.abs(high - low) + 1;
+  const windowCenter = (low + high + 1) / 2;
 
   return { windowWidth, windowCenter };
 }
 
 /**
  * Given a window width and center, return the lower and upper bounds of the window
+ * The formulas for the calculation are specified in
+ * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
+ * if (x <= c - 0.5 - (w-1) /2), then y = ymin
+ * else if (x > c - 0.5 + (w-1) /2), then y = ymax
+ * else y = ((x - (c - 0.5)) / (w-1) + 0.5) * (ymax- ymin) + ymin
  * @param windowWidth - the width of the window in HU
  * @param windowCenter - The center of the window.
  * @returns a JavaScript object with two properties: lower and upper.
@@ -30,8 +39,8 @@ function toLowHighRange(
   lower: number;
   upper: number;
 } {
-  const lower = windowCenter - windowWidth / 2.0;
-  const upper = windowCenter + windowWidth / 2.0;
+  const lower = windowCenter - 0.5 - (windowWidth - 1) / 2;
+  const upper = windowCenter - 0.5 + (windowWidth - 1) / 2;
 
   return { lower, upper };
 }