@cornerstonejs/tools 1.70.5 → 1.70.7

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/tools/base/AnnotationTool.ts

@@ -266,6 +266,7 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     const { viewport } = enabledElement;
 
     const { data } = annotation;
+    const { isCanvasAnnotation } = data;
     const { points, textBox } = data.handles;
 
     if (textBox) {
@@ -292,10 +293,15 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
 
     for (let i = 0; i < points?.length; i++) {
       const point = points[i];
-      const annotationCanvasCoordinate = viewport.worldToCanvas(point);
+      const annotationCanvasCoordinate = isCanvasAnnotation
+        ? point.slice(0, 2)
+        : viewport.worldToCanvas(point);
 
       const near =
-        vec2.distance(canvasCoords, annotationCanvasCoordinate) < proximity;
+        vec2.distance(
+          canvasCoords,
+          annotationCanvasCoordinate as Types.Point2
+        ) < proximity;
 
       if (near === true) {
         data.handles.activeHandleIndex = i;

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

@@ -361,6 +361,13 @@ function _setLabelmapColorAndOpacity(
 
   for (let i = 1; i < numColors; i++) {
     // Start from 1 to skip the background segment index.
+    const isHidden = segmentsHidden.has(i);
+
+    if (isHidden) {
+      outlineWidths[i - 1] = 0;
+      continue;
+    }
+
     outlineWidths[i - 1] =
       i === activeSegmentIndex
         ? outlineWidth + toolGroupLabelmapConfig.activeSegmentOutlineWidthDelta

package/src/tools/segmentation/BrushTool.ts

@@ -2,6 +2,9 @@ import {
   utilities as csUtils,
   cache,
   getEnabledElement,
+  StackViewport,
+  eventTarget,
+  Enums,
 } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
 
@@ -112,7 +115,6 @@ class BrushTool extends BaseTool {
         strategySpecificConfiguration: {
           THRESHOLD: {
             threshold: [-150, -70], // E.g. CT Fat // Only used during threshold strategies.
-            dynamicRadius: 0, // in voxel counts in each direction, only used during dynamic threshold strategies.
           },
         },
         defaultStrategy: 'FILL_INSIDE_CIRCLE',
@@ -208,6 +210,20 @@ class BrushTool extends BaseTool {
       ] as LabelmapSegmentationDataVolume;
       const actors = viewport.getActors();
 
+      const isStackViewport = viewport instanceof StackViewport;
+
+      if (isStackViewport) {
+        const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+          detail: {
+            type: 'Segmentation',
+            message: 'Cannot perform brush operation on the selected viewport',
+          },
+          cancelable: true,
+        });
+        eventTarget.dispatchEvent(event);
+        return null;
+      }
+
       // we used to take the first actor here but we should take the one that is
       // probably the same size as the segmentation volume
       const volumes = actors.map((actorEntry) =>

package/src/tools/segmentation/strategies/compositions/dynamicThreshold.ts

@@ -77,9 +77,15 @@ export default {
     const { configuration, viewport } = operationData;
     const { THRESHOLD: { dynamicRadius = 0 } = {} } =
       configuration.strategySpecificConfiguration || {};
+
+    if (dynamicRadius === 0) {
+      return;
+    }
+
     const { spacing } = (
       viewport as Types.IStackViewport | Types.IVolumeViewport
     ).getImageData();
+
     const centerCanvas = [
       viewport.element.clientWidth / 2,
       viewport.element.clientHeight / 2,

package/src/tools/segmentation/strategies/compositions/preview.ts

@@ -4,10 +4,19 @@ import { triggerSegmentationDataModified } from '../../../../stateManagement/seg
 import { config as segmentationConfig } from '../../../../stateManagement/segmentation';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 
+function lightenColor(r, g, b, a, factor = 0.4) {
+  return [
+    Math.round(r + (255 - r) * factor),
+    Math.round(g + (255 - g) * factor),
+    Math.round(b + (255 - b) * factor),
+    a,
+  ];
+}
+
 /**
- * Sets up a preview to use an alternate set of colours.  First fills the
+ * Sets up a preview to use an alternate set of colors.  First fills the
  * preview segment index with the final one for all pixels, then resets
- * the preview colours.
+ * the preview colors.
  * This is only activated when the preview segment index is defined, either
  * from the initial state or from the global state.
  */
@@ -71,7 +80,8 @@ export default {
     if (!configColor && !segmentColor) {
       return;
     }
-    const previewColor = configColor || segmentColor.map((it) => it * 0.9);
+    const previewColor = configColor || lightenColor(...segmentColor);
+
     segmentationConfig.color.setColorForSegmentIndex(
       toolGroupId,
       segmentationRepresentationUID,
@@ -88,7 +98,7 @@ export default {
       previewVoxelManager: previewVoxelManager,
       previewSegmentIndex,
       preview,
-    } = operationData;
+    } = operationData || {};
     if (previewSegmentIndex === undefined) {
       return;
     }

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -87,8 +87,9 @@ export interface AdvancedMagnifyAnnotation extends Annotation {
     zoomFactor: number;
     sourceViewportId: string;
     magnifyViewportId: string;
+    isCanvasAnnotation: boolean;
     handles: {
-      points: Types.Point3[]; // [top, right, bottom, left]
+      points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3]; // in canvas space
       activeHandleIndex: number | null;
     };
   };

package/src/utilities/cine/playClip.ts

@@ -198,10 +198,10 @@ function playClip(
  * Stops an already playing clip.
  * @param element - HTML Element
  */
-function stopClip(element: HTMLDivElement, viewportId?: string): void {
+function stopClip(element: HTMLDivElement, options = {} as any): void {
   _stopClip(element, {
     stopDynamicCine: true,
-    viewportId,
+    ...options,
   });
 }
 

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/planar/filterAnnotationsForDisplay.ts

@@ -47,6 +47,9 @@ export default function filterAnnotationsForDisplay(
     if (!annotation.isVisible) {
       return false;
     }
+    if (annotation.data.isCanvasAnnotation) {
+      return true;
+    }
     return viewport.isReferenceViewable(annotation.metadata, filterOptions);
   });
 }