@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.2

package/src/tools/displayTools/Labelmap/removeLabelmapFromElement.ts

@@ -1,4 +1,4 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { StackViewport, getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 /**
@@ -19,6 +19,11 @@ function removeLabelmapFromElement(
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
+  if (viewport instanceof StackViewport) {
+    // Todo: we don't have stack segmentation yet
+    return;
+  }
+
   (viewport as Types.IVolumeViewport).removeVolumeActors([
     segmentationRepresentationUID,
   ]);

package/src/tools/displayTools/SegmentationDisplayTool.ts

@@ -143,26 +143,20 @@ class SegmentationDisplayTool extends BaseTool {
         const config = this._getMergedRepresentationsConfig(toolGroupId);
 
         const viewportsRenderList = [];
+        const display =
+          representation.type === Representations.Labelmap
+            ? labelmapDisplay
+            : contourDisplay;
+
         for (const viewport of toolGroupViewports) {
-          if (representation.type == Representations.Labelmap) {
-            viewportsRenderList.push(
-              labelmapDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          } else if (representation.type == Representations.Contour) {
-            viewportsRenderList.push(
-              contourDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          }
-        }
+          const renderedViewport = display.render(
+            viewport as Types.IVolumeViewport,
+            representation,
+            config
+          );
 
+          viewportsRenderList.push(renderedViewport);
+        }
         return viewportsRenderList;
       }
     );

package/src/tools/index.ts

@@ -1,4 +1,4 @@
-import { BaseTool, AnnotationTool } from './base';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
 import PanTool from './PanTool';
 import TrackballRotateTool from './TrackballRotateTool';
 import WindowLevelTool from './WindowLevelTool';
@@ -43,6 +43,7 @@ export {
   // ~~ BASE
   BaseTool,
   AnnotationTool,
+  AnnotationDisplayTool,
   // Manipulation Tools
   PanTool,
   TrackballRotateTool,

package/src/tools/segmentation/BrushTool.ts

@@ -1,4 +1,5 @@
 import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
 
 import type { Types } from '@cornerstonejs/core';
 import type {
@@ -8,7 +9,10 @@ import type {
   SVGDrawingHelper,
 } from '../../types';
 import { BaseTool } from '../base';
-import { fillInsideSphere } from './strategies/fillSphere';
+import {
+  fillInsideSphere,
+  thresholdInsideSphere,
+} from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import {
   thresholdInsideCircle,
@@ -59,10 +63,11 @@ class BrushTool extends BaseTool {
       configuration: {
         strategies: {
           FILL_INSIDE_CIRCLE: fillInsideCircle,
-          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
           ERASE_INSIDE_CIRCLE: eraseInsideCircle,
           FILL_INSIDE_SPHERE: fillInsideSphere,
           ERASE_INSIDE_SPHERE: eraseInsideSphere,
+          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
+          THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
         },
         strategySpecificConfiguration: {
           THRESHOLD_INSIDE_CIRCLE: {
@@ -277,24 +282,42 @@ class BrushTool extends BaseTool {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const { canvasToWorld } = viewport;
+    const camera = viewport.getCamera();
     const { brushSize } = this.configuration;
-    // Center of circle in canvas Coordinates
 
-    const radius = brushSize;
+    const viewUp = vec3.fromValues(
+      camera.viewUp[0],
+      camera.viewUp[1],
+      camera.viewUp[2]
+    );
+    const viewPlaneNormal = vec3.fromValues(
+      camera.viewPlaneNormal[0],
+      camera.viewPlaneNormal[1],
+      camera.viewPlaneNormal[2]
+    );
+    const viewRight = vec3.create();
 
-    const bottomCanvas: Types.Point2 = [
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+
+    // in the world coordinate system, the brushSize is the radius of the circle
+    // in mm
+    const centerCursorInWorld: Types.Point3 = canvasToWorld([
       centerCanvas[0],
-      centerCanvas[1] + radius,
-    ];
-    const topCanvas: Types.Point2 = [centerCanvas[0], centerCanvas[1] - radius];
-    const leftCanvas: Types.Point2 = [
-      centerCanvas[0] - radius,
-      centerCanvas[1],
-    ];
-    const rightCanvas: Types.Point2 = [
-      centerCanvas[0] + radius,
       centerCanvas[1],
-    ];
+    ]);
+
+    const bottomCursorInWorld = vec3.create();
+    const topCursorInWorld = vec3.create();
+    const leftCursorInWorld = vec3.create();
+    const rightCursorInWorld = vec3.create();
+
+    // Calculate the bottom and top points of the circle in world coordinates
+    for (let i = 0; i <= 2; i++) {
+      bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
+      topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
+      leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
+      rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
+    }
 
     const { brushCursor } = this._hoverData;
     const { data } = brushCursor;
@@ -304,10 +327,10 @@ class BrushTool extends BaseTool {
     }
 
     data.handles.points = [
-      canvasToWorld(bottomCanvas),
-      canvasToWorld(topCanvas),
-      canvasToWorld(leftCanvas),
-      canvasToWorld(rightCanvas),
+      bottomCursorInWorld,
+      topCursorInWorld,
+      leftCursorInWorld,
+      rightCursorInWorld,
     ];
 
     data.invalidated = false;

package/src/tools/segmentation/PaintFillTool.ts

@@ -90,7 +90,10 @@ class PaintFillTool extends BaseTool {
 
     const index = transformWorldToIndex(segmentation.imageData, worldPos);
 
-    const fixedDimension = this.getFixedDimension(viewPlaneNormal, direction);
+    const fixedDimension = this.getFixedDimension(
+      viewPlaneNormal,
+      direction as number[]
+    );
 
     if (fixedDimension === undefined) {
       console.warn('Oblique paint fill not yet supported');
@@ -169,8 +172,12 @@ class PaintFillTool extends BaseTool {
     for (let b = 0; b < boundaries.length; b++) {
       const j = boundaries[b][1];
 
-      if (j < minJ) minJ = j;
-      if (j > maxJ) maxJ = j;
+      if (j < minJ) {
+        minJ = j;
+      }
+      if (j > maxJ) {
+        maxJ = j;
+      }
     }
 
     const framesModified = [];

package/src/tools/segmentation/strategies/eraseSphere.ts

@@ -4,6 +4,7 @@ import { fillInsideSphere } from './fillSphere';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+  imageVolume: Types.IImageVolume;
   volume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
@@ -11,6 +12,7 @@ type OperationData = {
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
   constraintFn: () => boolean;
+  strategySpecificConfiguration: any;
 };
 
 export function eraseInsideSphere(

package/src/tools/segmentation/strategies/fillCircle.ts

@@ -9,6 +9,7 @@ import {
 import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInShapeCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -117,19 +118,6 @@ function fillCircle(
   triggerSegmentationDataModified(segmentationId, arrayOfSlices);
 }
 
-function isWithinThreshold(
-  index: number,
-  imageVolume: Types.IImageVolume,
-  strategySpecificConfiguration: any
-) {
-  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
-
-  const voxelValue = imageVolume.getScalarData()[index];
-  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-
-  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
-}
-
 /**
  * Fill inside the circular region segment inside the segmentation defined by the operationData.
  * It fills the segmentation pixels inside the defined circle.

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -1,29 +1,36 @@
 import type { Types } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
 
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { pointInSurroundingSphereCallback } from '../../../utilities';
+import isWithinThreshold from './utils/isWithinThreshold';
 
 type OperationData = {
   points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
   volume: Types.IImageVolume;
+  imageVolume: Types.IImageVolume;
   segmentIndex: number;
   segmentationId: string;
   segmentsLocked: number[];
   viewPlaneNormal: Types.Point3;
   viewUp: Types.Point3;
+  strategySpecificConfiguration: any;
   constraintFn: () => boolean;
 };
 
 function fillSphere(
   enabledElement: Types.IEnabledElement,
   operationData: OperationData,
-  _inside = true
+  _inside = true,
+  threshold = false
 ): void {
   const { viewport } = enabledElement;
   const {
     volume: segmentation,
     segmentsLocked,
     segmentIndex,
+    imageVolume,
+    strategySpecificConfiguration,
     segmentationId,
     points,
   } = operationData;
@@ -32,13 +39,30 @@ function fillSphere(
   const scalarData = segmentation.getScalarData();
   const scalarIndex = [];
 
-  const callback = ({ index, value }) => {
-    if (segmentsLocked.includes(value)) {
-      return;
-    }
-    scalarData[index] = segmentIndex;
-    scalarIndex.push(index);
-  };
+  let callback;
+
+  if (threshold) {
+    callback = ({ value, index, pointIJK }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+
+      if (
+        isWithinThreshold(index, imageVolume, strategySpecificConfiguration)
+      ) {
+        scalarData[index] = segmentIndex;
+        scalarIndex.push(index);
+      }
+    };
+  } else {
+    callback = ({ index, value }) => {
+      if (segmentsLocked.includes(value)) {
+        return;
+      }
+      scalarData[index] = segmentIndex;
+      scalarIndex.push(index);
+    };
+  }
 
   pointInSurroundingSphereCallback(
     imageData,
@@ -74,6 +98,30 @@ export function fillInsideSphere(
   fillSphere(enabledElement, operationData, true);
 }
 
+/**
+ * Fill inside the circular region segment inside the segmentation defined by the operationData.
+ * It fills the segmentation pixels inside the defined circle.
+ * @param enabledElement - The element for which the segment is being filled.
+ * @param operationData - EraseOperationData
+ */
+export function thresholdInsideSphere(
+  enabledElement: Types.IEnabledElement,
+  operationData: OperationData
+): void {
+  const { volume, imageVolume } = operationData;
+
+  if (
+    !csUtils.isEqual(volume.dimensions, imageVolume.dimensions) ||
+    !csUtils.isEqual(volume.direction, imageVolume.direction)
+  ) {
+    throw new Error(
+      'Only source data the same dimensions/size/orientation as the segmentation currently supported.'
+    );
+  }
+
+  fillSphere(enabledElement, operationData, true, true);
+}
+
 /**
  * Fill outside a sphere with the given segment index in the given operation data. The
  * operation data contains the sphere required points.

package/src/tools/segmentation/strategies/utils/isWithinThreshold.ts

@@ -0,0 +1,16 @@
+import { Types } from '@cornerstonejs/core';
+
+function isWithinThreshold(
+  index: number,
+  imageVolume: Types.IImageVolume,
+  strategySpecificConfiguration: any
+) {
+  const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+
+  const voxelValue = imageVolume.getScalarData()[index];
+  const { threshold } = THRESHOLD_INSIDE_CIRCLE;
+
+  return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+}
+
+export default isWithinThreshold;

package/src/types/CINETypes.ts

@@ -1,5 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-
 type PlayClipOptions = {
   framesPerSecond?: number;
   frameTimeVector?: number[];
@@ -7,6 +5,11 @@ type PlayClipOptions = {
   loop?: boolean;
   dynamicCineEnabled?: boolean;
   frameTimeVectorSpeedMultiplier?: number;
+  // How many CINE frames to wait for a rendered event to occur before
+  // trying to display the image after the next one
+  // A CINE frame is attempted every 1 / fps seconds
+  // The default is 30 tries, or 1.25 seconds at 24 fps
+  waitForRendered?: number;
 };
 
 interface ToolData {
@@ -26,6 +29,9 @@ type CinePlayContext = {
   get numScrollSteps(): number;
   get currentStepIndex(): number;
   get frameTimeVectorEnabled(): boolean;
+  // How many times has the wait for rendered been tried without showing
+  // the next image.
+  waitForRenderedCount?: number;
   scroll(delta: number): void;
 };
 

package/src/types/CalculatorTypes.ts

@@ -0,0 +1,7 @@
+type Statistics = {
+  name: string;
+  value: number;
+  unit: null | string;
+};
+
+export type { Statistics };

package/src/types/EventTypes.ts

@@ -3,6 +3,7 @@ import { Annotation } from './AnnotationTypes';
 import IPoints from './IPoints';
 import ITouchPoints from './ITouchPoints';
 import IDistance from './IDistance';
+import { SetToolBindingsType } from './ISetToolModeOptions';
 import { Swipe } from '../enums/Touch';
 
 /**
@@ -70,6 +71,18 @@ type InteractionStartEventDetail = InteractionEventDetail;
 
 type InteractionEndEventDetail = InteractionEventDetail;
 
+/**
+ * The data that is passed to the event handler when a tool is activated.
+ */
+type ToolActivatedEventDetail = {
+  /** unique id of the toolGroup */
+  toolGroupId: string;
+  /** Tool name */
+  toolName: string;
+  /** Tool binding options */
+  toolBindingsOptions: SetToolBindingsType;
+};
+
 /**
  * The data that is passed to the event handler when a new annotation is added
  * to the annotations.
@@ -411,6 +424,11 @@ type NormalizedMouseEventType = Types.CustomEventType<MouseCustomEventDetail>;
  */
 type NormalizedTouchEventType = Types.CustomEventType<TouchCustomEventDetail>;
 
+/**
+ * The ToolActivated event type
+ */
+type ToolActivatedEventType = Types.CustomEventType<ToolActivatedEventDetail>;
+
 /**
  * The AnnotationAdded event type
  */
@@ -611,6 +629,8 @@ export {
   NormalizedInteractionEventDetail,
   NormalizedMouseEventType,
   NormalizedTouchEventType,
+  ToolActivatedEventDetail,
+  ToolActivatedEventType,
   AnnotationAddedEventDetail,
   AnnotationAddedEventType,
   AnnotationCompletedEventDetail,

package/src/types/ISetToolModeOptions.ts

@@ -1,9 +1,9 @@
 import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
 
-type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+type ToolBindingMouseType = (typeof MouseBindings)[keyof typeof MouseBindings];
 
 type ToolBindingKeyboardType =
-  typeof KeyboardBindings[keyof typeof KeyboardBindings];
+  (typeof KeyboardBindings)[keyof typeof KeyboardBindings];
 
 type IToolBinding = {
   /** Mouse button bindings e.g., MouseBindings.Primary/Secondary etc. */

package/src/types/IToolGroup.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
 import { MouseBindings } from '../enums';
+import { ToolConfiguration } from '../types';
 /**
  * ToolGroup interface
  */
@@ -19,8 +20,10 @@ export default interface IToolGroup {
   getViewportsInfo: () => Array<Types.IViewportId>;
   /** Get the toolInstance of the toolName */
   getToolInstance: { (toolName: string): any };
-  /** Add a tool to toolGroup with its configuration */
-  addTool: { (toolName: string, toolConfiguration?: any): void };
+  /** Add a tool to toolGroup with its configuration and custom calculator if wanted */
+  addTool: {
+    (toolName: string, toolConfiguration?: ToolConfiguration): void;
+  };
   /** Add tool instance, if you want to create more than one instance from the same tool e.g., brush/eraser tool */
   addToolInstance: {
     (ttoolName: string, parentClassName: string, configuration?: any): void;
@@ -62,7 +65,7 @@ export default interface IToolGroup {
   setToolConfiguration: {
     (
       toolName: string,
-      configuration: Record<any, any>,
+      configuration: ToolConfiguration,
       overwrite?: boolean
     ): void;
   };

package/src/types/ToolProps.ts

@@ -1,8 +1,14 @@
+import { Calculator } from '../utilities/math/basic';
+
 type SharedToolProp = {
   /** supported interactions for the tool */
   supportedInteractionTypes?: Array<string>;
   /** tool specific tool configuration */
-  configuration?: Record<string, any>;
+  configuration?: ToolConfiguration;
+};
+
+export type ToolConfiguration = Record<string, any> & {
+  statsCalculator?: Calculator;
 };
 
 export type ToolProps = SharedToolProp;

package/src/types/index.ts

@@ -21,7 +21,11 @@ import type * as AnnotationStyle from './AnnotationStyle';
 import type ToolHandle from './ToolHandle';
 import type { AnnotationHandle, TextBoxHandle } from './ToolHandle';
 import type InteractionTypes from './InteractionTypes';
-import type { ToolProps, PublicToolProps } from './ToolProps';
+import type {
+  ToolProps,
+  PublicToolProps,
+  ToolConfiguration,
+} from './ToolProps';
 import type { SVGCursorDescriptor, SVGPoint } from './CursorTypes';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type ScrollOptions from './ScrollOptions';
@@ -52,6 +56,7 @@ import IToolClassReference from './IToolClassReference';
 import { ContourSegmentationData } from './ContourTypes';
 import IAnnotationManager from './IAnnotationManager';
 import AnnotationGroupSelector from './AnnotationGroupSelector';
+import { Statistics } from './CalculatorTypes';
 
 export type {
   // AnnotationState
@@ -68,6 +73,7 @@ export type {
   PlanarBoundingBox,
   ToolProps,
   PublicToolProps,
+  ToolConfiguration,
   // Event data
   EventTypes,
   IPoints,
@@ -114,4 +120,6 @@ export type {
   FloodFillOptions,
   // Contour
   ContourSegmentationData,
+  //Statistics
+  Statistics,
 };

package/src/utilities/cine/playClip.ts

@@ -6,6 +6,7 @@ import {
   VolumeViewport,
   cache,
   BaseVolumeViewport,
+  Enums,
 } from '@cornerstonejs/core';
 
 import { Types } from '@cornerstonejs/core';
@@ -14,6 +15,7 @@ import { addToolState, getToolState } from './state';
 import { CINETypes } from '../../types';
 import scroll from '../scroll';
 
+const { ViewportStatus } = Enums;
 const { triggerEvent } = csUtils;
 
 const debounced = true;
@@ -193,7 +195,9 @@ function stopClip(element: HTMLDivElement): void {
 
 function _stopClip(element: HTMLDivElement, stopDynamicCine: boolean): void {
   const enabledElement = getEnabledElement(element);
-  if (!enabledElement) return;
+  if (!enabledElement) {
+    return;
+  }
   const { viewport } = enabledElement;
   const cineToolData = getToolState(viewport.element);
 
@@ -313,7 +317,8 @@ function _getVolumeFromViewport(viewport): Types.IImageVolume {
 }
 
 function _createStackViewportCinePlayContext(
-  viewport: StackViewport
+  viewport: StackViewport,
+  waitForRendered: number
 ): CINETypes.CinePlayContext {
   const imageIds = viewport.getImageIds();
 
@@ -328,7 +333,16 @@ function _createStackViewportCinePlayContext(
       // It is always in acquired orientation
       return true;
     },
+    waitForRenderedCount: 0,
     scroll(delta: number): void {
+      if (
+        this.waitForRenderedCount <= waitForRendered &&
+        viewport.viewportStatus !== ViewportStatus.RENDERED
+      ) {
+        this.waitForRenderedCount++;
+        return;
+      }
+      this.waitForRenderedCount = 0;
       scroll(viewport, { delta, debounceLoading: debounced });
     },
   };
@@ -417,7 +431,10 @@ function _createCinePlayContext(
   playClipOptions: CINETypes.PlayClipOptions
 ): CINETypes.CinePlayContext {
   if (viewport instanceof StackViewport) {
-    return _createStackViewportCinePlayContext(viewport);
+    return _createStackViewportCinePlayContext(
+      viewport,
+      playClipOptions.waitForRendered ?? 30
+    );
   }
 
   if (viewport instanceof VolumeViewport) {

package/src/utilities/dynamicVolume/getDataInTime.ts

@@ -40,13 +40,16 @@ function getDataInTime(
 
   if (options.maskVolumeId) {
     const segmentationVolume = cache.getVolume(options.maskVolumeId);
+    const segScalarData = segmentationVolume.getScalarData();
+    const indexArray = [];
+
+    // Get the index of every non-zero voxel in mask
+    for (let i = 0, len = segScalarData.length; i < len; i++) {
+      if (segScalarData[i] !== 0) {
+        indexArray.push(i);
+      }
+    }
 
-    // Get the index of every non-zero voxel in mask by mapping indexes to
-    // new array, then using the array to filter
-    const indexArray = segmentationVolume
-      .getScalarData()
-      .map((_, i) => i)
-      .filter((i) => segmentationVolume.getScalarData()[i] !== 0);
     const dataInTime = _getTimePointDataMask(frames, indexArray, dynamicVolume);
 
     return dataInTime;

package/src/utilities/getCalibratedUnits.ts

@@ -23,10 +23,16 @@ 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;
+  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';
+  if (calibration.SequenceOfUltrasoundRegions) {
+    return 'US Region';
+  }
   return `${units} ${calibration.type}`;
 };
 
@@ -37,8 +43,12 @@ const SQUARE = '\xb2';
 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';
+  if (!calibration || !calibration.type) {
+    return units;
+  }
+  if (calibration.SequenceOfUltrasoundRegions) {
+    return 'US Region';
+  }
   return `${units} ${calibration.type}`;
 };