@cornerstonejs/tools 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -27,7 +27,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.5.0",
+    "@cornerstonejs/core": "^1.7.0",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -50,5 +50,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "cbfe5342099f46b69109d34e09a0a733ca7c897d"
+  "gitHead": "757fe06aab211f0bd506c40f262264e90290b702"
 }

package/src/tools/annotation/AngleTool.ts

@@ -16,6 +16,7 @@ import {
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import * as lineSegment from '../../utilities/math/line';
 import angleBetweenLines from '../../utilities/math/angle/angleBetweenLines';
+import roundNumber from '../../utilities/roundNumber';
 
 import {
   drawHandles as drawHandlesSvg,
@@ -200,7 +201,6 @@ class AngleTool extends AnnotationTool {
     const [point1, point2, point3] = data.handles.points;
     const canvasPoint1 = viewport.worldToCanvas(point1);
     const canvasPoint2 = viewport.worldToCanvas(point2);
-    const canvasPoint3 = viewport.worldToCanvas(point3);
 
     const line1 = {
       start: {
@@ -213,6 +213,17 @@ class AngleTool extends AnnotationTool {
       },
     };
 
+    const distanceToPoint = lineSegment.distanceToPoint(
+      [line1.start.x, line1.start.y],
+      [line1.end.x, line1.end.y],
+      [canvasCoords[0], canvasCoords[1]]
+    );
+
+    if (distanceToPoint <= proximity) return true;
+    if (!point3) return false;
+
+    const canvasPoint3 = viewport.worldToCanvas(point3);
+
     const line2 = {
       start: {
         x: canvasPoint2[0],
@@ -224,19 +235,13 @@ class AngleTool extends AnnotationTool {
       },
     };
 
-    const distanceToPoint = lineSegment.distanceToPoint(
-      [line1.start.x, line1.start.y],
-      [line1.end.x, line1.end.y],
-      [canvasCoords[0], canvasCoords[1]]
-    );
-
     const distanceToPoint2 = lineSegment.distanceToPoint(
       [line2.start.x, line2.start.y],
       [line2.end.x, line2.end.y],
       [canvasCoords[0], canvasCoords[1]]
     );
 
-    if (distanceToPoint <= proximity || distanceToPoint2 <= proximity) {
+    if (distanceToPoint2 <= proximity) {
       return true;
     }
 
@@ -783,7 +788,7 @@ class AngleTool extends AnnotationTool {
       return;
     }
 
-    const textLines = [`${angle.toFixed(2)} ${String.fromCharCode(176)}`];
+    const textLines = [`${roundNumber(angle)} ${String.fromCharCode(176)}`];
 
     return textLines;
   }

package/src/tools/annotation/BidirectionalTool.ts

@@ -1,4 +1,4 @@
-import { vec2, vec3, mat2, mat3, mat2d } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
 import {
   getEnabledElement,
   triggerEvent,
@@ -7,6 +7,11 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
+import {
+  getCalibratedLengthUnits,
+  getCalibratedScale,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import {
@@ -1252,8 +1257,8 @@ class BidirectionalTool extends AnnotationTool {
     // spaceBetweenSlices & pixelSpacing &
     // magnitude in each direction? Otherwise, this is "px"?
     const textLines = [
-      `L: ${length.toFixed(2)} ${unit}`,
-      `W: ${width.toFixed(2)} ${unit}`,
+      `L: ${roundNumber(length)} ${unit}`,
+      `W: ${roundNumber(width)} ${unit}`,
     ];
 
     return textLines;
@@ -1291,10 +1296,10 @@ class BidirectionalTool extends AnnotationTool {
         continue;
       }
 
-      const { imageData, dimensions, hasPixelSpacing } = image;
-
-      const dist1 = this._calculateLength(worldPos1, worldPos2);
-      const dist2 = this._calculateLength(worldPos3, worldPos4);
+      const { imageData, dimensions } = image;
+      const scale = getCalibratedScale(image);
+      const dist1 = this._calculateLength(worldPos1, worldPos2) / scale;
+      const dist2 = this._calculateLength(worldPos3, worldPos4) / scale;
       const length = dist1 > dist2 ? dist1 : dist2;
       const width = dist1 > dist2 ? dist2 : dist1;
 
@@ -1310,7 +1315,7 @@ class BidirectionalTool extends AnnotationTool {
       cachedStats[targetId] = {
         length,
         width,
-        unit: hasPixelSpacing ? 'mm' : 'px',
+        unit: getCalibratedLengthUnits(null, image),
       };
     }
 

package/src/tools/annotation/CircleROITool.ts

@@ -9,6 +9,13 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
+import {
+  getCalibratedLengthUnits,
+  getCalibratedAreaUnits,
+  getCalibratedScale,
+  getCalibratedAspect,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,
@@ -876,27 +883,27 @@ class CircleROITool extends AnnotationTool {
     if (radius) {
       const radiusLine = isEmptyArea
         ? `Radius: Oblique not supported`
-        : `Radius: ${radius.toFixed(2)} ${radiusUnit}`;
+        : `Radius: ${roundNumber(radius)} ${radiusUnit}`;
       textLines.push(radiusLine);
     }
 
     if (area) {
       const areaLine = isEmptyArea
         ? `Area: Oblique not supported`
-        : `Area: ${area.toFixed(2)} ${areaUnit}\xb2`;
+        : `Area: ${roundNumber(area)} ${areaUnit}`;
       textLines.push(areaLine);
     }
 
     if (mean) {
-      textLines.push(`Mean: ${mean.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
     }
 
     if (max) {
-      textLines.push(`Max: ${max.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
     }
 
     if (stdDev) {
-      textLines.push(`Std Dev: ${stdDev.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
     }
 
     return textLines;
@@ -994,7 +1001,13 @@ class CircleROITool extends AnnotationTool {
           worldPos2
         );
         const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-        const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2));
+        const scale = getCalibratedScale(image);
+        const aspect = getCalibratedAspect(image);
+        const area = Math.abs(
+          Math.PI *
+            (worldWidth / scale / 2) *
+            (worldHeight / aspect / scale / 2)
+        );
 
         let count = 0;
         let mean = 0;
@@ -1048,10 +1061,10 @@ class CircleROITool extends AnnotationTool {
           max,
           stdDev,
           isEmptyArea,
-          areaUnit: hasPixelSpacing ? 'mm' : 'px',
-          radius: worldWidth / 2,
-          radiusUnit: hasPixelSpacing ? 'mm' : 'px',
-          perimeter: 2 * Math.PI * (worldWidth / 2),
+          areaUnit: getCalibratedAreaUnits(null, image),
+          radius: worldWidth / 2 / scale,
+          radiusUnit: getCalibratedLengthUnits(null, image),
+          perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
           modalityUnit,
         };
       } else {

package/src/tools/annotation/EllipticalROITool.ts

@@ -9,6 +9,11 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
+import {
+  getCalibratedAreaUnits,
+  getCalibratedScale,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,
@@ -994,20 +999,20 @@ class EllipticalROITool extends AnnotationTool {
     if (area) {
       const areaLine = isEmptyArea
         ? `Area: Oblique not supported`
-        : `Area: ${area.toFixed(2)} ${areaUnit}\xb2`;
+        : `Area: ${roundNumber(area)} ${areaUnit}`;
       textLines.push(areaLine);
     }
 
     if (mean) {
-      textLines.push(`Mean: ${mean.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
     }
 
     if (max) {
-      textLines.push(`Max: ${max.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
     }
 
     if (stdDev) {
-      textLines.push(`Std Dev: ${stdDev.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
     }
 
     return textLines;
@@ -1105,7 +1110,11 @@ class EllipticalROITool extends AnnotationTool {
           worldPos2
         );
         const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-        const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2));
+        const scale = getCalibratedScale(image);
+        const area =
+          Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
+          scale /
+          scale;
 
         let count = 0;
         let mean = 0;
@@ -1159,7 +1168,7 @@ class EllipticalROITool extends AnnotationTool {
           max,
           stdDev,
           isEmptyArea,
-          areaUnit: hasPixelSpacing ? 'mm' : 'px',
+          areaUnit: getCalibratedAreaUnits(null, image),
           modalityUnit,
         };
       } else {

package/src/tools/annotation/LengthTool.ts

@@ -7,6 +7,11 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
+import {
+  getCalibratedLengthUnits,
+  getCalibratedScale,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import {
@@ -43,7 +48,6 @@ import {
   TextBoxHandle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { LengthAnnotation } from '../../types/ToolSpecificAnnotationTypes';
@@ -776,7 +780,7 @@ class LengthTool extends AnnotationTool {
       return;
     }
 
-    const textLines = [`${length.toFixed(2)} ${unit}`];
+    const textLines = [`${roundNumber(length)} ${unit}`];
 
     return textLines;
   }
@@ -812,9 +816,10 @@ class LengthTool extends AnnotationTool {
         continue;
       }
 
-      const { imageData, dimensions, hasPixelSpacing } = image;
+      const { imageData, dimensions } = image;
+      const scale = getCalibratedScale(image);
 
-      const length = this._calculateLength(worldPos1, worldPos2);
+      const length = this._calculateLength(worldPos1, worldPos2) / scale;
 
       const index1 = transformWorldToIndex(imageData, worldPos1);
       const index2 = transformWorldToIndex(imageData, worldPos2);
@@ -830,7 +835,7 @@ class LengthTool extends AnnotationTool {
       // todo: add insideVolume calculation, for removing tool if outside
       cachedStats[targetId] = {
         length,
-        unit: hasPixelSpacing ? 'mm' : 'px',
+        unit: getCalibratedLengthUnits(null, image),
       };
     }
 

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -9,6 +9,12 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
+
+import {
+  getCalibratedAreaUnits,
+  getCalibratedScale,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import { Events } from '../../enums';
 import { AnnotationTool } from '../base';
 import {
@@ -737,9 +743,11 @@ class PlanarFreehandROITool extends AnnotationTool {
         continue;
       }
 
-      const { imageData, metadata, hasPixelSpacing } = image;
+      const { imageData, metadata } = image;
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-      const area = polyline.calculateAreaOfPoints(canvasCoordinates);
+      const scale = getCalibratedScale(image);
+      const area =
+        polyline.calculateAreaOfPoints(canvasCoordinates) / scale / scale;
 
       const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
       worldPosIndex[0] = Math.floor(worldPosIndex[0]);
@@ -868,7 +876,7 @@ class PlanarFreehandROITool extends AnnotationTool {
         mean,
         max,
         stdDev,
-        areaUnit: hasPixelSpacing ? 'mm' : 'px',
+        areaUnit: getCalibratedAreaUnits(null, image),
         modalityUnit,
       };
     }
@@ -939,20 +947,20 @@ class PlanarFreehandROITool extends AnnotationTool {
     if (area) {
       const areaLine = isEmptyArea
         ? `Area: Oblique not supported`
-        : `Area: ${area.toFixed(2)} ${areaUnit}\xb2`;
+        : `Area: ${roundNumber(area)} ${areaUnit}`;
       textLines.push(areaLine);
     }
 
     if (mean) {
-      textLines.push(`Mean: ${mean.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
     }
 
     if (max) {
-      textLines.push(`Max: ${max.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
     }
 
     if (stdDev) {
-      textLines.push(`Std Dev: ${stdDev.toFixed(2)} ${modalityUnit}`);
+      textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
     }
 
     return textLines;

package/src/tools/annotation/RectangleROITool.ts

@@ -9,6 +9,11 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
+import {
+  getCalibratedAreaUnits,
+  getCalibratedScale,
+} from '../../utilities/getCalibratedUnits';
+import roundNumber from '../../utilities/roundNumber';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,
@@ -859,10 +864,10 @@ class RectangleROITool extends AnnotationTool {
 
     const textLines: string[] = [];
 
-    textLines.push(`Area: ${area.toFixed(2)} ${areaUnit}\xb2`);
-    textLines.push(`Mean: ${mean.toFixed(2)} ${modalityUnit}`);
-    textLines.push(`Max: ${max.toFixed(2)} ${modalityUnit}`);
-    textLines.push(`Std Dev: ${stdDev.toFixed(2)} ${modalityUnit}`);
+    textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
 
     return textLines;
   };
@@ -907,7 +912,7 @@ class RectangleROITool extends AnnotationTool {
         continue;
       }
 
-      const { dimensions, imageData, metadata, hasPixelSpacing } = image;
+      const { dimensions, imageData, metadata } = image;
       const scalarData =
         'getScalarData' in image ? image.getScalarData() : image.scalarData;
 
@@ -946,8 +951,9 @@ class RectangleROITool extends AnnotationTool {
           worldPos1,
           worldPos2
         );
+        const scale = getCalibratedScale(image);
 
-        const area = Math.abs(worldWidth * worldHeight);
+        const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
 
         let count = 0;
         let mean = 0;
@@ -1004,7 +1010,7 @@ class RectangleROITool extends AnnotationTool {
           mean,
           stdDev,
           max,
-          areaUnit: hasPixelSpacing ? 'mm' : 'px',
+          areaUnit: getCalibratedAreaUnits(null, image),
           modalityUnit,
         };
       } else {

package/src/tools/base/AnnotationDisplayTool.ts

@@ -7,8 +7,6 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import { vec4 } from 'gl-matrix';
-
 import BaseTool from './BaseTool';
 import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
 import { Annotation, Annotations, SVGDrawingHelper } from '../../types';
@@ -30,6 +28,7 @@ import { StyleSpecifier } from '../../types/AnnotationStyle';
  */
 abstract class AnnotationDisplayTool extends BaseTool {
   static toolName;
+
   // ===================================================================
   // Abstract Methods - Must be implemented.
   // ===================================================================
@@ -83,31 +82,16 @@ abstract class AnnotationDisplayTool extends BaseTool {
   public onImageSpacingCalibrated = (
     evt: Types.EventTypes.ImageSpacingCalibratedEvent
   ) => {
-    const {
-      element,
-      rowScale,
-      columnScale,
-      imageId,
-      imageData: calibratedImageData,
-      worldToIndex: nonCalibratedWorldToIndex,
-    } = evt.detail;
-
-    const { viewport } = getEnabledElement(element);
-
-    if (viewport instanceof VolumeViewport) {
-      throw new Error('Cannot calibrate a volume viewport');
-    }
-
-    const calibratedIndexToWorld = calibratedImageData.getIndexToWorld();
+    const { element, imageId } = evt.detail;
 
     const imageURI = utilities.imageIdToURI(imageId);
-    const stateManager = getAnnotationManager();
-    const framesOfReference = stateManager.getFramesOfReference();
+    const annotationManager = getAnnotationManager();
+    const framesOfReference = annotationManager.getFramesOfReference();
 
     // For each frame Of Reference
     framesOfReference.forEach((frameOfReference) => {
       const frameOfReferenceSpecificAnnotations =
-        stateManager.getAnnotations(frameOfReference);
+        annotationManager.getAnnotations(frameOfReference);
 
       const toolSpecificAnnotations =
         frameOfReferenceSpecificAnnotations[this.getToolName()];
@@ -128,44 +112,8 @@ abstract class AnnotationDisplayTool extends BaseTool {
           // we can update the cachedStats and also rendering
           annotation.invalidated = true;
           annotation.data.cachedStats = {};
-
-          // Update annotation points to the new calibrated points. Basically,
-          // using the worldToIndex function we get the index on the non-calibrated
-          // image and then using the calibratedIndexToWorld function we get the
-          // corresponding point on the calibrated image world.
-          annotation.data.handles.points = annotation.data.handles.points.map(
-            (point) => {
-              const p = vec4.fromValues(...(point as Types.Point3), 1);
-              const pCalibrated = vec4.fromValues(0, 0, 0, 1);
-              const nonCalibratedIndexVec4 = vec4.create();
-              vec4.transformMat4(
-                nonCalibratedIndexVec4,
-                p,
-                nonCalibratedWorldToIndex
-              );
-              const calibratedIndex = [
-                columnScale * nonCalibratedIndexVec4[0],
-                rowScale * nonCalibratedIndexVec4[1],
-                nonCalibratedIndexVec4[2],
-              ];
-
-              vec4.transformMat4(
-                pCalibrated,
-                vec4.fromValues(
-                  calibratedIndex[0],
-                  calibratedIndex[1],
-                  calibratedIndex[2],
-                  1
-                ),
-                calibratedIndexToWorld
-              );
-
-              return pCalibrated.slice(0, 3) as Types.Point3;
-            }
-          );
         }
       });
-
       triggerAnnotationRender(element);
     });
   };

package/src/utilities/calibrateImageSpacing.ts

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, Enums } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 const { calibratedPixelSpacingMetadataProvider } = utilities;
@@ -9,25 +9,22 @@ const { calibratedPixelSpacingMetadataProvider } = utilities;
  * their reference imageIds. Finally, it triggers a re-render for invalidated annotations.
  * @param imageId - ImageId for the calibrated image
  * @param rowPixelSpacing - Spacing in row direction
- * @param columnPixelSpacing - Spacing in column direction
- * @param renderingEngine - Cornerstone RenderingEngine instance
+ * @param calibrationOrScale - either the calibration object or a scale value
  */
 export default function calibrateImageSpacing(
   imageId: string,
   renderingEngine: Types.IRenderingEngine,
-  rowPixelSpacing: number,
-  columnPixelSpacing: number
+  calibrationOrScale: Types.IImageCalibration | number
 ): void {
-  // 1. Add the calibratedPixelSpacing metadata to the metadata provider
-  // If no column spacing provided, assume square pixels
-  if (!columnPixelSpacing) {
-    columnPixelSpacing = rowPixelSpacing;
+  // Handle simple parameter version
+  if (typeof calibrationOrScale === 'number') {
+    calibrationOrScale = {
+      type: Enums.CalibrationTypes.USER,
+      scale: calibrationOrScale,
+    };
   }
-
-  calibratedPixelSpacingMetadataProvider.add(imageId, {
-    rowPixelSpacing,
-    columnPixelSpacing,
-  });
+  // 1. Add the calibratedPixelSpacing metadata to the metadata
+  calibratedPixelSpacingMetadataProvider.add(imageId, calibrationOrScale);
 
   // 2. Update the actor for stackViewports
   const viewports = renderingEngine.getStackViewports();

package/src/utilities/getCalibratedUnits.ts

@@ -0,0 +1,66 @@
+import { Enums } from '@cornerstonejs/core';
+
+const { CalibrationTypes } = Enums;
+const PIXEL_UNITS = 'px';
+
+/**
+ * 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 calibraiton 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) return units;
+  if (calibration.type === CalibrationTypes.UNCALIBRATED) return PIXEL_UNITS;
+  // TODO - handle US regions properly
+  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) => image.calibration?.scale || 1;
+
+/** Gets the aspect ratio of the screen display relative to the image
+ * display in order to square up measurement values.
+ * That is, suppose the spacing on the image is 1, 0.5 (x,y spacing)
+ * This is displayed at 1, 1 spacing on screen, then the
+ * aspect value will be 1/0.5 = 2
+ */
+const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
+
+export default getCalibratedLengthUnits;
+
+export {
+  getCalibratedAreaUnits,
+  getCalibratedLengthUnits,
+  getCalibratedScale,
+  getCalibratedAspect,
+};

package/src/utilities/index.ts

@@ -16,6 +16,7 @@ import jumpToSlice from './viewport/jumpToSlice';
 import pointInShapeCallback from './pointInShapeCallback';
 import pointInSurroundingSphereCallback from './pointInSurroundingSphereCallback';
 import scroll from './scroll';
+import roundNumber from './roundNumber';
 
 // name spaces
 import * as segmentation from './segmentation';
@@ -65,4 +66,5 @@ export {
   planarFreehandROITool,
   stackPrefetch,
   scroll,
+  roundNumber,
 };