@cornerstonejs/tools 1.70.6 → 1.70.8

package/src/tools/annotation/RectangleROITool.ts

@@ -7,10 +7,7 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import {
-  getCalibratedAreaUnits,
-  getCalibratedScale,
-} from '../../utilities/getCalibratedUnits';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import {
@@ -878,37 +875,35 @@ class RectangleROITool extends AnnotationTool {
       }
 
       const { dimensions, imageData, metadata } = image;
-      const scalarData =
-        'getScalarData' in image ? image.getScalarData() : image.scalarData;
 
-      const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
+      const pos1Index = transformWorldToIndex(imageData, worldPos1);
 
-      worldPos1Index[0] = Math.floor(worldPos1Index[0]);
-      worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-      worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+      pos1Index[0] = Math.floor(pos1Index[0]);
+      pos1Index[1] = Math.floor(pos1Index[1]);
+      pos1Index[2] = Math.floor(pos1Index[2]);
 
-      const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
+      const pos2Index = transformWorldToIndex(imageData, worldPos2);
 
-      worldPos2Index[0] = Math.floor(worldPos2Index[0]);
-      worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-      worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+      pos2Index[0] = Math.floor(pos2Index[0]);
+      pos2Index[1] = Math.floor(pos2Index[1]);
+      pos2Index[2] = Math.floor(pos2Index[2]);
 
       // Check if one of the indexes are inside the volume, this then gives us
       // Some area to do stats over.
 
-      if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
+      if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
         this.isHandleOutsideImage = false;
 
         // Calculate index bounds to iterate over
 
-        const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
-        const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
+        const iMin = Math.min(pos1Index[0], pos2Index[0]);
+        const iMax = Math.max(pos1Index[0], pos2Index[0]);
 
-        const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);
-        const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
+        const jMin = Math.min(pos1Index[1], pos2Index[1]);
+        const jMax = Math.max(pos1Index[1], pos2Index[1]);
 
-        const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
-        const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
+        const kMin = Math.min(pos1Index[2], pos2Index[2]);
+        const kMax = Math.max(pos1Index[2], pos2Index[2]);
 
         const boundsIJK = [
           [iMin, iMax],
@@ -922,7 +917,12 @@ class RectangleROITool extends AnnotationTool {
           worldPos1,
           worldPos2
         );
-        const scale = getCalibratedScale(image);
+
+        const handles = [pos1Index, pos2Index];
+        const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(
+          image,
+          handles
+        );
 
         const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
 
@@ -959,7 +959,7 @@ class RectangleROITool extends AnnotationTool {
           max: stats.max?.value,
           statsArray: stats.array,
           pointsInShape: pointsInShape,
-          areaUnit: getCalibratedAreaUnits(null, image),
+          areaUnit: areaUnits,
           modalityUnit,
         };
       } else {

package/src/tools/annotation/SplineROITool.ts

@@ -37,8 +37,7 @@ import {
   throttle,
   roundNumber,
   triggerAnnotationRenderForViewportIds,
-  getCalibratedScale,
-  getCalibratedAreaUnits,
+  getCalibratedLengthUnitsAndScale,
 } from '../../utilities';
 import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
@@ -1163,7 +1162,40 @@ class SplineROITool extends ContourSegmentationBaseTool {
       const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
       const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
 
-      const scale = getCalibratedScale(image);
+      const { imageData } = image;
+      const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(
+        image,
+        () => {
+          const {
+            maxX: canvasMaxX,
+            maxY: canvasMaxY,
+            minX: canvasMinX,
+            minY: canvasMinY,
+          } = math.polyline.getAABB(canvasCoordinates);
+
+          const topLeftBBWorld = viewport.canvasToWorld([
+            canvasMinX,
+            canvasMinY,
+          ]);
+
+          const topLeftBBIndex = utilities.transformWorldToIndex(
+            imageData,
+            topLeftBBWorld
+          );
+
+          const bottomRightBBWorld = viewport.canvasToWorld([
+            canvasMaxX,
+            canvasMaxY,
+          ]);
+
+          const bottomRightBBIndex = utilities.transformWorldToIndex(
+            imageData,
+            bottomRightBBWorld
+          );
+
+          return [topLeftBBIndex, bottomRightBBIndex];
+        }
+      );
       let area = math.polyline.getArea(canvasCoordinates) / scale / scale;
 
       // Convert from canvas_pixels ^2 to mm^2
@@ -1172,7 +1204,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
       cachedStats[targetId] = {
         Modality: metadata.Modality,
         area,
-        areaUnit: getCalibratedAreaUnits(null, image),
+        areaUnit: areaUnits,
       };
     }
 

package/src/utilities/getCalibratedUnits.ts

@@ -21,72 +21,7 @@ const UNIT_MAPPING = {
 };
 
 const EPS = 1e-3;
-
-/**
- * Extracts the length units and the type of calibration for those units
- * into the response.  The length units will typically be either mm or px
- * while the calibration type can be any of a number of different calibration types.
- *
- * Volumetric images have no calibration type, so are just the raw mm.
- *
- * TODO: Handle region calibration
- *
- * @param handles - used to detect if the spacing information is different
- *   between various points (eg angled ERMF or US Region).
- *   Currently unused, but needed for correct US Region handling
- * @param image - to extract the calibration from
- *        image.calibration - calibration value to extract units form
- * @returns String containing the units and type of calibration
- */
-const getCalibratedLengthUnits = (handles, image): string => {
-  const { calibration, hasPixelSpacing } = image;
-  // Anachronistic - moving to using calibration consistently, but not completed yet
-  const units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-  if (
-    !calibration ||
-    (!calibration.type && !calibration.sequenceOfUltrasoundRegions)
-  ) {
-    return units;
-  }
-  if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-    return PIXEL_UNITS;
-  }
-  if (calibration.sequenceOfUltrasoundRegions) {
-    return 'US Region';
-  }
-  return `${units} ${calibration.type}`;
-};
-
 const SQUARE = '\xb2';
-/**
- *  Extracts the area units, including the squared sign plus calibration type.
- */
-const getCalibratedAreaUnits = (handles, image): string => {
-  const { calibration, hasPixelSpacing } = image;
-  const units = (hasPixelSpacing ? 'mm' : PIXEL_UNITS) + SQUARE;
-  if (!calibration || !calibration.type) {
-    return units;
-  }
-  if (calibration.sequenceOfUltrasoundRegions) {
-    return 'US Region';
-  }
-  return `${units} ${calibration.type}`;
-};
-
-/**
- * Gets the scale divisor for converting from internal spacing to
- * image spacing for calibrated images.
- */
-const getCalibratedScale = (image, handles = []) => {
-  if (image.calibration?.sequenceOfUltrasoundRegions) {
-    // image.spacing / image.us.space
-  } else if (image.calibration?.scale) {
-    return image.calibration.scale;
-  } else {
-    return 1;
-  }
-};
-
 /**
  * Extracts the calibrated length units, area units, and the scale
  * for converting from internal spacing to image spacing.
@@ -96,10 +31,9 @@ const getCalibratedScale = (image, handles = []) => {
  * @returns Object containing the units, area units, and scale
  */
 const getCalibratedLengthUnitsAndScale = (image, handles) => {
-  const [imageIndex1, imageIndex2] = handles;
   const { calibration, hasPixelSpacing } = image;
   let units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-  const areaUnits = units + SQUARE;
+  let areaUnits = units + SQUARE;
   let scale = 1;
   let calibrationType = '';
 
@@ -115,6 +49,15 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
   }
 
   if (calibration.sequenceOfUltrasoundRegions) {
+    let imageIndex1, imageIndex2;
+    if (Array.isArray(handles) && handles.length === 2) {
+      [imageIndex1, imageIndex2] = handles;
+    } else if (typeof handles === 'function') {
+      const points = handles();
+      imageIndex1 = points[0];
+      imageIndex2 = points[1];
+    }
+
     let regions = calibration.sequenceOfUltrasoundRegions.filter(
       (region) =>
         imageIndex1[0] >= region.regionLocationMinX0 &&
@@ -165,17 +108,23 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
     );
 
     if (isSamePhysicalDelta) {
-      scale = 1 / (physicalDeltaX * physicalDeltaY * 100);
+      // 1 to 1 aspect ratio, we use just one of them
+      scale = 1 / (physicalDeltaX * 10);
       calibrationType = 'US Region';
       units = 'mm';
+      areaUnits = 'mm' + SQUARE;
     } else {
+      // here we are showing at the aspect ratio of the physical delta
+      // if they are not the same, then we should show px, but the correct solution
+      // is to grab each point separately and scale them individually
+      // Todo: implement this
       return { units: PIXEL_UNITS, areaUnits: PIXEL_UNITS + SQUARE, scale };
     }
   } else if (calibration.scale) {
     scale = calibration.scale;
   }
 
-  // everything except REGION/Uncalibratted
+  // everything except REGION/Uncalibrated
   const types = [
     CalibrationTypes.ERMF,
     CalibrationTypes.USER,
@@ -272,13 +221,8 @@ const getCalibratedProbeUnitsAndValue = (image, handles) => {
  */
 const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
 
-export default getCalibratedLengthUnits;
-
 export {
-  getCalibratedAreaUnits,
-  getCalibratedLengthUnits,
   getCalibratedLengthUnitsAndScale,
-  getCalibratedScale,
   getCalibratedAspect,
   getCalibratedProbeUnitsAndValue,
 };

package/src/utilities/index.ts

@@ -12,9 +12,9 @@ import isObject from './isObject';
 import clip from './clip';
 import calibrateImageSpacing from './calibrateImageSpacing';
 import {
-  getCalibratedLengthUnits,
-  getCalibratedAreaUnits,
-  getCalibratedScale,
+  getCalibratedLengthUnitsAndScale,
+  getCalibratedProbeUnitsAndValue,
+  getCalibratedAspect,
 } from './getCalibratedUnits';
 import triggerAnnotationRenderForViewportIds from './triggerAnnotationRenderForViewportIds';
 import triggerAnnotationRenderForToolGroupIds from './triggerAnnotationRenderForToolGroupIds';
@@ -67,9 +67,9 @@ export {
   touch,
   triggerEvent,
   calibrateImageSpacing,
-  getCalibratedLengthUnits,
-  getCalibratedAreaUnits,
-  getCalibratedScale,
+  getCalibratedLengthUnitsAndScale,
+  getCalibratedProbeUnitsAndValue,
+  getCalibratedAspect,
   segmentation,
   contours,
   triggerAnnotationRenderForViewportIds,

package/src/utilities/stackPrefetch/stackContextPrefetch.ts

@@ -217,7 +217,10 @@ function prefetch(element) {
       .loadAndCacheImage(imageId, options)
       .then(() => doneCallback(imageId));
 
-  const { useNorm16Texture } = getCoreConfiguration().rendering;
+  const { useNorm16Texture, preferSizeOverAccuracy } =
+    getCoreConfiguration().rendering;
+
+  const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
 
   indicesToRequestCopy.forEach((imageIdIndex) => {
     const imageId = stack.imageIds[imageIdIndex];
@@ -225,11 +228,12 @@ function prefetch(element) {
     // highest priority will be used for the request type in the imageRetrievalPool
     const options = {
       targetBuffer: {
-        type: useNorm16Texture ? undefined : 'Float32Array',
+        type: useNativeDataType ? undefined : 'Float32Array',
       },
       preScale: {
         enabled: true,
       },
+      useNativeDataType,
       requestType,
     };
 

package/src/utilities/stackPrefetch/stackPrefetch.ts

@@ -166,18 +166,22 @@ function prefetch(element) {
   const requestFn = (imageId, options) =>
     imageLoader.loadAndCacheImage(imageId, options);
 
-  const { useNorm16Texture } = getCoreConfiguration().rendering;
+  const { useNorm16Texture, preferSizeOverAccuracy } =
+    getCoreConfiguration().rendering;
+
+  const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
 
   imageIdsToPrefetch.forEach((imageId) => {
     // IMPORTANT: Request type should be passed if not the 'interaction'
     // highest priority will be used for the request type in the imageRetrievalPool
     const options = {
       targetBuffer: {
-        type: useNorm16Texture ? undefined : 'Float32Array',
+        type: useNativeDataType ? undefined : 'Float32Array',
       },
       preScale: {
         enabled: true,
       },
+      useNativeDataType,
       requestType,
     };