@cornerstonejs/tools 1.40.3 → 1.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.40.3",
+  "version": "1.42.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.40.3",
+    "@cornerstonejs/core": "^1.42.0",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "5a4bedfe6e8f2b217347109cd0e0c85b7c5bf1d0"
+  "gitHead": "75102c80b6bc3714f00590b92ccd8d4d52bf1ca2"
 }

package/src/drawingSvg/drawHandle.ts

@@ -0,0 +1,88 @@
+import type { Types } from '@cornerstonejs/core';
+
+import _getHash from './_getHash';
+import setNewAttributesIfValid from './setNewAttributesIfValid';
+import setAttributesIfNecessary from './setAttributesIfNecessary';
+import { SVGDrawingHelper } from '../types';
+
+function drawHandle(
+  svgDrawingHelper: SVGDrawingHelper,
+  annotationUID: string,
+  handleGroupUID: string,
+  handle: Types.Point2,
+  options = {},
+  uniqueIndex
+): void {
+  const { color, handleRadius, width, lineWidth, fill, type, opacity } =
+    Object.assign(
+      {
+        color: 'dodgerblue',
+        handleRadius: '6',
+        width: '2',
+        lineWidth: undefined,
+        fill: 'transparent',
+        type: 'circle',
+        opacity: 1,
+      },
+      options
+    );
+
+  // for supporting both lineWidth and width options
+  const strokeWidth = lineWidth || width;
+
+  // variable for the namespace
+  const svgns = 'http://www.w3.org/2000/svg';
+  const svgNodeHash = _getHash(
+    annotationUID,
+    'handle',
+    `hg-${handleGroupUID}-index-${uniqueIndex}`
+  );
+
+  let attributes;
+  if (type === 'circle') {
+    attributes = {
+      cx: `${handle[0]}`,
+      cy: `${handle[1]}`,
+      r: handleRadius,
+      stroke: color,
+      fill,
+      'stroke-width': strokeWidth,
+      opacity: opacity,
+    };
+  } else if (type === 'rect') {
+    const handleRadiusFloat = parseFloat(handleRadius);
+    const side = handleRadiusFloat * 1.5;
+    const x = handle[0] - side * 0.5;
+    const y = handle[1] - side * 0.5;
+
+    attributes = {
+      x: `${x}`,
+      y: `${y}`,
+      width: `${side}`,
+      height: `${side}`,
+      stroke: color,
+      fill,
+      'stroke-width': strokeWidth,
+      rx: `${side * 0.1}`,
+      opacity: opacity,
+    };
+  } else {
+    throw new Error(`Unsupported handle type: ${type}`);
+  }
+
+  const existingHandleElement = svgDrawingHelper.getSvgNode(svgNodeHash);
+
+  if (existingHandleElement) {
+    setAttributesIfNecessary(attributes, existingHandleElement);
+
+    svgDrawingHelper.setNodeTouched(svgNodeHash);
+  } else {
+    const newHandleElement = document.createElementNS(svgns, type);
+
+    setNewAttributesIfValid(attributes, newHandleElement);
+
+    svgDrawingHelper.appendNode(newHandleElement, svgNodeHash);
+  }
+}
+
+export default drawHandle;

package/src/drawingSvg/drawHandles.ts

@@ -1,9 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 
-import _getHash from './_getHash';
-import setNewAttributesIfValid from './setNewAttributesIfValid';
-import setAttributesIfNecessary from './setAttributesIfNecessary';
 import { SVGDrawingHelper } from '../types';
+import drawHandle from './drawHandle';
 
 function drawHandles(
   svgDrawingHelper: SVGDrawingHelper,
@@ -12,80 +10,16 @@ function drawHandles(
   handlePoints: Array<Types.Point2>,
   options = {}
 ): void {
-  const { color, handleRadius, width, lineWidth, fill, type, opacity } =
-    Object.assign(
-      {
-        color: 'dodgerblue',
-        handleRadius: '6',
-        width: '2',
-        lineWidth: undefined,
-        fill: 'transparent',
-        type: 'circle',
-        opacity: 1,
-      },
-      options
-    );
-
-  // for supporting both lineWidth and width options
-  const strokeWidth = lineWidth || width;
-
-  for (let i = 0; i < handlePoints.length; i++) {
-    const handle = handlePoints[i];
-
-    // variable for the namespace
-    const svgns = 'http://www.w3.org/2000/svg';
-    const svgNodeHash = _getHash(
+  handlePoints.forEach((handle, i) => {
+    drawHandle(
+      svgDrawingHelper,
       annotationUID,
-      'handle',
-      `hg-${handleGroupUID}-index-${i}`
+      handleGroupUID,
+      handle,
+      options,
+      i
     );
-
-    let attributes;
-    if (type === 'circle') {
-      attributes = {
-        cx: `${handle[0]}`,
-        cy: `${handle[1]}`,
-        r: handleRadius,
-        stroke: color,
-        fill,
-        'stroke-width': strokeWidth,
-        opacity: opacity,
-      };
-    } else if (type === 'rect') {
-      const handleRadiusFloat = parseFloat(handleRadius);
-      const side = handleRadiusFloat * 1.5;
-      const x = handle[0] - side * 0.5;
-      const y = handle[1] - side * 0.5;
-
-      attributes = {
-        x: `${x}`,
-        y: `${y}`,
-        width: `${side}`,
-        height: `${side}`,
-        stroke: color,
-        fill,
-        'stroke-width': strokeWidth,
-        rx: `${side * 0.1}`,
-        opacity: opacity,
-      };
-    } else {
-      throw new Error(`Unsupported handle type: ${type}`);
-    }
-
-    const existingHandleElement = svgDrawingHelper.getSvgNode(svgNodeHash);
-
-    if (existingHandleElement) {
-      setAttributesIfNecessary(attributes, existingHandleElement);
-
-      svgDrawingHelper.setNodeTouched(svgNodeHash);
-    } else {
-      const newHandleElement = document.createElementNS(svgns, type);
-
-      setNewAttributesIfValid(attributes, newHandleElement);
-
-      svgDrawingHelper.appendNode(newHandleElement, svgNodeHash);
-    }
-  }
+  });
 }
 
 export default drawHandles;

package/src/drawingSvg/index.ts

@@ -3,6 +3,7 @@ import drawCircle from './drawCircle';
 import drawEllipse from './drawEllipse';
 import drawEllipseByCoordinates from './drawEllipseByCoordinates';
 import drawHandles from './drawHandles';
+import drawHandle from './drawHandle';
 import drawLine from './drawLine';
 import drawPolyline from './drawPolyline';
 import drawLinkedTextBox from './drawLinkedTextBox';
@@ -19,6 +20,7 @@ export {
   drawEllipse,
   drawEllipseByCoordinates,
   drawHandles,
+  drawHandle,
   drawLine,
   drawPolyline,
   drawLinkedTextBox,

package/src/eventDispatchers/keyboardEventHandlers/keyDown.ts

@@ -34,7 +34,13 @@ export default function keyDown(evt: KeyDownEventType): void {
   if (activeToolsWithEventBinding?.size) {
     const { element } = evt.detail;
     for (const [key, value] of [...activeToolsWithEventBinding.entries()]) {
-      key[value.method](element);
+      // Calls the method that implements the action, which can be a string
+      // in which case it belongs to the tool instance, or a function
+      // Call it on the tool instance, with the element and configuration value
+      // so that the method can depend on the specific configuration in use.
+      const method =
+        typeof value.method === 'function' ? value.method : key[value.method];
+      method.call(key, element, value);
     }
   }
 }

package/src/index.ts

@@ -56,6 +56,7 @@ import {
   BrushTool,
   AngleTool,
   CobbAngleTool,
+  UltrasoundDirectionalTool,
   MagnifyTool,
   AdvancedMagnifyTool,
   ReferenceCursors,
@@ -111,6 +112,7 @@ export {
   ArrowAnnotateTool,
   AngleTool,
   CobbAngleTool,
+  UltrasoundDirectionalTool,
   KeyImageTool,
   MagnifyTool,
   AdvancedMagnifyTool,

package/src/stateManagement/annotation/annotationState.ts

@@ -126,6 +126,9 @@ function getNumberOfAnnotations(
  * @param annotationUID - The unique identifier for the annotation.
  */
 function removeAnnotation(annotationUID: string): void {
+  if (!annotationUID) {
+    return;
+  }
   const manager = getAnnotationManager();
   const annotation = manager.getAnnotation(annotationUID);
 

package/src/tools/annotation/AngleTool.ts

@@ -43,7 +43,6 @@ import {
   TextBoxHandle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { AngleAnnotation } from '../../types/ToolSpecificAnnotationTypes';

package/src/tools/annotation/BidirectionalTool.ts

@@ -1348,19 +1348,23 @@ class BidirectionalTool extends AnnotationTool {
 }
 
 function defaultGetTextLines(data, targetId): string[] {
-  const { cachedStats } = data;
+  const { cachedStats, label } = data;
   const { length, width, unit } = cachedStats[targetId];
 
+  const textLines = [];
+  if (label) {
+    textLines.push(label);
+  }
   if (length === undefined) {
-    return;
+    return textLines;
   }
 
   // spaceBetweenSlices & pixelSpacing &
   // magnitude in each direction? Otherwise, this is "px"?
-  const textLines = [
+  textLines.push(
     `L: ${roundNumber(length)} ${unit}`,
-    `W: ${roundNumber(width)} ${unit}`,
-  ];
+    `W: ${roundNumber(width)} ${unit}`
+  );
 
   return textLines;
 }

package/src/tools/annotation/LengthTool.ts

@@ -7,10 +7,7 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import {
-  getCalibratedLengthUnits,
-  getCalibratedScale,
-} from '../../utilities/getCalibratedUnits';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import roundNumber from '../../utilities/roundNumber';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
@@ -818,12 +815,13 @@ class LengthTool extends AnnotationTool {
       }
 
       const { imageData, dimensions } = image;
-      const scale = getCalibratedScale(image);
-
-      const length = this._calculateLength(worldPos1, worldPos2) / scale;
 
       const index1 = transformWorldToIndex(imageData, worldPos1);
       const index2 = transformWorldToIndex(imageData, worldPos2);
+      const handles = [index1, index2];
+      const { scale, units } = getCalibratedLengthUnitsAndScale(image, handles);
+
+      const length = this._calculateLength(worldPos1, worldPos2) / scale;
 
       this._isInsideVolume(index1, index2, dimensions)
         ? (this.isHandleOutsideImage = false)
@@ -836,7 +834,7 @@ class LengthTool extends AnnotationTool {
       // todo: add insideVolume calculation, for removing tool if outside
       cachedStats[targetId] = {
         length,
-        unit: getCalibratedLengthUnits(null, image),
+        unit: units,
       };
     }
 

package/src/tools/annotation/ProbeTool.ts

@@ -16,6 +16,7 @@ import {
   getAnnotations,
   removeAnnotation,
 } from '../../stateManagement/annotation/annotationState';
+import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUnits';
 import {
   drawHandles as drawHandlesSvg,
   drawTextBox as drawTextBoxSvg,
@@ -590,7 +591,7 @@ class ProbeTool extends AnnotationTool {
           index[2] * zMultiple +
           index[1] * yMultiple +
           index[0] * samplesPerPixel;
-        const value =
+        let value =
           samplesPerPixel > 2
             ? [
                 scalarData[baseIndex],
@@ -614,11 +615,28 @@ class ProbeTool extends AnnotationTool {
           index[2] = viewport.getCurrentImageIdIndex();
         }
 
-        const modalityUnit = getModalityUnit(
-          modality,
-          annotation.metadata.referencedImageId,
-          modalityUnitOptions
-        );
+        let modalityUnit;
+
+        if (modality === 'US') {
+          const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
+            index,
+          ]);
+
+          const hasEnhancedRegionValues = calibratedResults.values.every(
+            (value) => value !== null
+          );
+
+          value = hasEnhancedRegionValues ? calibratedResults.values : value;
+          modalityUnit = hasEnhancedRegionValues
+            ? calibratedResults.units
+            : 'raw';
+        } else {
+          modalityUnit = getModalityUnit(
+            modality,
+            annotation.metadata.referencedImageId,
+            modalityUnitOptions
+          );
+        }
 
         cachedStats[targetId] = {
           index,
@@ -664,7 +682,13 @@ function defaultGetTextLines(data, targetId): string[] {
 
   textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
 
-  textLines.push(`${roundNumber(value)} ${modalityUnit}`);
+  if (value instanceof Array && modalityUnit instanceof Array) {
+    for (let i = 0; i < value.length; i++) {
+      textLines.push(`${roundNumber(value[i])} ${modalityUnit[i]}`);
+    }
+  } else {
+    textLines.push(`${roundNumber(value)} ${modalityUnit}`);
+  }
 
   return textLines;
 }