@cornerstonejs/core 0.41.1 → 0.41.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "0.41.1",
+  "version": "0.41.2",
   "description": "",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -51,5 +51,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "8e8c4693642dab1c46c38381f66730b40b187e79"
+  "gitHead": "e682bc7d33796f1ff962e42f3bed54d276dc6ad4"
 }

package/src/RenderingEngine/StackViewport.ts

@@ -1536,11 +1536,15 @@ class StackViewport extends Viewport implements IStackViewport {
     const columnCosines = direction.slice(3, 6);
     const dataType = imageData.getPointData().getScalars().getDataType();
 
+    // using epsilon comparison for float numbers comparison.
+    const isSameXSpacing = isEqual(xSpacing, image.rowPixelSpacing);
+    const isSameYSpacing = isEqual(ySpacing, image.columnPixelSpacing);
+
     // using spacing, size, and direction only for now
     return (
-      (xSpacing === image.rowPixelSpacing ||
+      (isSameXSpacing ||
         (image.rowPixelSpacing === null && xSpacing === 1.0)) &&
-      (ySpacing === image.columnPixelSpacing ||
+      (isSameYSpacing ||
         (image.columnPixelSpacing === null && ySpacing === 1.0)) &&
       xVoxels === image.columns &&
       yVoxels === image.rows &&

package/src/utilities/isEqual.ts

@@ -1,27 +1,74 @@
+function areNumbersEqualWithTolerance(
+  num1: number,
+  num2: number,
+  tolerance: number
+): boolean {
+  return Math.abs(num1 - num2) <= tolerance;
+}
+
+function areArraysEqual(
+  arr1: ArrayLike<number>,
+  arr2: ArrayLike<number>,
+  tolerance = 1e-5
+): boolean {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < arr1.length; i++) {
+    if (!areNumbersEqualWithTolerance(arr1[i], arr2[i], tolerance)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function isNumberType(value: any): value is number {
+  return typeof value === 'number';
+}
+
+function isNumberArrayLike(value: any): value is ArrayLike<number> {
+  return 'length' in value && typeof value[0] === 'number';
+}
+
 /**
- * returns equal if the two arrays are identical within the
- * given tolerance.
+ * Returns whether two values are equal or not, based on epsilon comparison.
+ * For array comparison, it does NOT strictly compare them but only compare its values.
+ * It can compare array of numbers and also typed array. Otherwise it will just return false.
  *
- * @param v1 - The first array of values
- * @param v2 - The second array of values.
+ * @param v1 - The first value to compare
+ * @param v2 - The second value to compare
  * @param tolerance - The acceptable tolerance, the default is 0.00001
  *
  * @returns True if the two values are within the tolerance levels.
  */
-export default function isEqual(
-  v1: number[] | Float32Array,
-  v2: number[] | Float32Array,
+export default function isEqual<ValueType>(
+  v1: ValueType,
+  v2: ValueType,
   tolerance = 1e-5
 ): boolean {
-  if (v1.length !== v2.length) {
+  // values must be the same type or not null
+  if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
     return false;
   }
 
-  for (let i = 0; i < v1.length; i++) {
-    if (Math.abs(v1[i] - v2[i]) > tolerance) {
-      return false;
-    }
+  // typeof object must have same constructor
+  if (
+    typeof v1 === 'object' &&
+    typeof v2 === 'object' &&
+    v1.constructor !== v2.constructor
+  ) {
+    return false;
   }
 
-  return true;
+  if (isNumberType(v1) && isNumberType(v2)) {
+    return areNumbersEqualWithTolerance(v1, v2, tolerance);
+  }
+
+  if (isNumberArrayLike(v1) && isNumberArrayLike(v2)) {
+    return areArraysEqual(v1, v2, tolerance);
+  }
+
+  return false;
 }