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

package/src/tools/annotation/DragProbeTool.ts

@@ -166,26 +166,19 @@ class DragProbeTool extends ProbeTool {
       ),
     };
 
-    if (!data.cachedStats[targetId]) {
+    if (
+      !data.cachedStats[targetId] ||
+      data.cachedStats[targetId].value == null
+    ) {
       data.cachedStats[targetId] = {
         Modality: null,
         index: null,
         value: null,
       };
 
-      this._calculateCachedStats(
-        annotation,
-        renderingEngine,
-        enabledElement,
-        modalityUnitOptions
-      );
+      this._calculateCachedStats(annotation, renderingEngine, enabledElement);
     } else if (annotation.invalidated) {
-      this._calculateCachedStats(
-        annotation,
-        renderingEngine,
-        enabledElement,
-        modalityUnitOptions
-      );
+      this._calculateCachedStats(annotation, renderingEngine, enabledElement);
     }
 
     // If rendering engine has been destroyed while rendering

package/src/tools/annotation/EllipticalROITool.ts

@@ -47,7 +47,6 @@ import {
   TextBoxHandle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { EllipticalROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
@@ -55,8 +54,6 @@ import { EllipticalROIAnnotation } from '../../types/ToolSpecificAnnotationTypes
 import {
   AnnotationCompletedEventDetail,
   AnnotationModifiedEventDetail,
-  MouseDragEventType,
-  MouseMoveEventType,
 } from '../../types/EventTypes';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { pointInShapeCallback } from '../../utilities/';
@@ -128,7 +125,7 @@ class EllipticalROITool extends AnnotationTool {
     viewportIdsToRender: Array<string>;
     handleIndex?: number;
     movingTextBox?: boolean;
-    centerCanvas?: Array<number>;
+    centerWorld?: Array<number>;
     canvasWidth?: number;
     canvasHeight?: number;
     originalHandleCanvas?: Array<number>;
@@ -241,7 +238,7 @@ class EllipticalROITool extends AnnotationTool {
     this.editData = {
       annotation,
       viewportIdsToRender,
-      centerCanvas: canvasPos,
+      centerWorld: worldPos,
       newAnnotation: true,
       hasMoved: false,
     };
@@ -368,6 +365,7 @@ class EllipticalROITool extends AnnotationTool {
     let handleIndex;
 
     let centerCanvas;
+    let centerWorld;
     let canvasWidth;
     let canvasHeight;
     let originalHandleCanvas;
@@ -376,8 +374,8 @@ class EllipticalROITool extends AnnotationTool {
       movingTextBox = true;
     } else {
       const { points } = data.handles;
-      const enabledElement = getEnabledElement(element);
-      const { worldToCanvas } = enabledElement.viewport;
+      const { viewport } = getEnabledElement(element);
+      const { worldToCanvas, canvasToWorld } = viewport;
 
       handleIndex = points.findIndex((p) => p === handle);
 
@@ -392,6 +390,8 @@ class EllipticalROITool extends AnnotationTool {
         (pointsCanvas[2][0] + pointsCanvas[3][0]) / 2,
         (pointsCanvas[0][1] + pointsCanvas[1][1]) / 2,
       ];
+
+      centerWorld = canvasToWorld(centerCanvas);
     }
 
     // Find viewports to render on drag.
@@ -406,7 +406,7 @@ class EllipticalROITool extends AnnotationTool {
       handleIndex,
       canvasWidth,
       canvasHeight,
-      centerCanvas,
+      centerWorld,
       originalHandleCanvas,
       movingTextBox,
     };
@@ -483,7 +483,8 @@ class EllipticalROITool extends AnnotationTool {
     const { canvasToWorld } = viewport;
 
     //////
-    const { annotation, viewportIdsToRender, centerCanvas } = this.editData;
+    const { annotation, viewportIdsToRender, centerWorld } = this.editData;
+    const centerCanvas = viewport.worldToCanvas(centerWorld as Types.Point3);
     const { data } = annotation;
 
     const dX = Math.abs(currentCanvasPoints[0] - centerCanvas[0]);
@@ -557,17 +558,18 @@ class EllipticalROITool extends AnnotationTool {
   _dragHandle = (evt: EventTypes.InteractionEventType): void => {
     const eventDetail = evt.detail;
     const { element } = eventDetail;
-    const enabledElement = getEnabledElement(element);
-    const { canvasToWorld } = enabledElement.viewport;
+    const { viewport } = getEnabledElement(element);
+    const { canvasToWorld, worldToCanvas } = viewport;
 
     const {
       annotation,
       canvasWidth,
       canvasHeight,
       handleIndex,
-      centerCanvas,
+      centerWorld,
       originalHandleCanvas,
     } = this.editData;
+    const centerCanvas = viewport.worldToCanvas(centerWorld as Types.Point3);
     const { data } = annotation;
     const { points } = data.handles;
 
@@ -800,21 +802,11 @@ class EllipticalROITool extends AnnotationTool {
 
       const { centerPointRadius } = this.configuration;
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
       // If cachedStats does not exist, or the unit is missing (as part of import/hydration etc.),
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].areaUnit === undefined
+        data.cachedStats[targetId].areaUnit == null
       ) {
         data.cachedStats[targetId] = {
           Modality: null,
@@ -829,16 +821,14 @@ class EllipticalROITool extends AnnotationTool {
           annotation,
           viewport,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
       } else if (annotation.invalidated) {
         this._throttledCalculateCachedStats(
           annotation,
           viewport,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
         // If the invalidated data is as a result of volumeViewport manipulation
         // of the tools, we need to invalidate the related viewports data, so that
@@ -1013,8 +1003,7 @@ class EllipticalROITool extends AnnotationTool {
     annotation,
     viewport,
     renderingEngine,
-    enabledElement,
-    modalityUnitOptions: ModalityUnitOptions
+    enabledElement
   ) => {
     const data = annotation.data;
     const { viewportId, renderingEngineId } = enabledElement;
@@ -1107,6 +1096,16 @@ class EllipticalROITool extends AnnotationTool {
           scale /
           scale;
 
+        const modalityUnitOptions = {
+          isPreScaled: isViewportPreScaled(viewport, targetId),
+
+          isSuvScaled: this.isSuvScaled(
+            viewport,
+            targetId,
+            annotation.metadata.referencedImageId
+          ),
+        };
+
         const modalityUnit = getModalityUnit(
           metadata.Modality,
           annotation.metadata.referencedImageId,

package/src/tools/annotation/LengthTool.ts

@@ -662,7 +662,7 @@ class LengthTool extends AnnotationTool {
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].unit === undefined
+        data.cachedStats[targetId].unit == null
       ) {
         data.cachedStats[targetId] = {
           length: null,

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -44,14 +44,13 @@ import {
   AnnotationStyle,
   PublicToolProps,
   ToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
-import { drawLine, drawCircle, drawLinkedTextBox } from '../../drawingSvg';
+import { drawLinkedTextBox } from '../../drawingSvg';
 import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { PlanarFreehandROICommonData } from '../../utilities/math/polyline/planarFreehandROIInternalTypes';
-import pointInPolyline from '../../utilities/math/polyline/pointInPolyline';
+
 import { getIntersectionCoordinatesWithPolyline } from '../../utilities/math/polyline/getIntersectionWithPolyline';
 import pointInShapeCallback from '../../utilities/pointInShapeCallback';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
@@ -679,20 +678,11 @@ class PlanarFreehandROITool extends AnnotationTool {
         return;
       }
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
       if (!this.commonData?.movingTextBox) {
         const { data } = annotation;
         if (
           !data.cachedStats[targetId] ||
-          data.cachedStats[targetId].areaUnit === undefined
+          data.cachedStats[targetId].areaUnit == null
         ) {
           data.cachedStats[targetId] = {
             Modality: null,
@@ -707,16 +697,14 @@ class PlanarFreehandROITool extends AnnotationTool {
             annotation,
             viewport,
             renderingEngine,
-            enabledElement,
-            modalityUnitOptions
+            enabledElement
           );
         } else if (annotation.invalidated) {
           this._throttledCalculateCachedStats(
             annotation,
             viewport,
             renderingEngine,
-            enabledElement,
-            modalityUnitOptions
+            enabledElement
           );
         }
       }
@@ -731,8 +719,7 @@ class PlanarFreehandROITool extends AnnotationTool {
     annotation,
     viewport,
     renderingEngine,
-    enabledElement,
-    modalityUnitOptions: ModalityUnitOptions
+    enabledElement
   ) => {
     const data = annotation.data;
     const { cachedStats, polyline: points } = data;
@@ -752,9 +739,28 @@ class PlanarFreehandROITool extends AnnotationTool {
 
       const { imageData, metadata } = image;
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+
+      // Using an arbitrary start point (canvasPoint), calculate the
+      // mm spacing for the canvas in the X and Y directions.
+      const canvasPoint = canvasCoordinates[0];
+      const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+      const deltaXPoint = viewport.canvasToWorld([
+        canvasPoint[0] + 1,
+        canvasPoint[1],
+      ]);
+      const deltaYPoint = viewport.canvasToWorld([
+        canvasPoint[0],
+        canvasPoint[1] + 1,
+      ]);
+
+      const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
+      const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
+
       const scale = getCalibratedScale(image);
-      const area =
+      let area =
         polyline.calculateAreaOfPoints(canvasCoordinates) / scale / scale;
+      // Convert from canvas_pixels ^2 to mm^2
+      area *= deltaInX * deltaInY;
 
       const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
       worldPosIndex[0] = Math.floor(worldPosIndex[0]);
@@ -850,6 +856,15 @@ class PlanarFreehandROITool extends AnnotationTool {
         boundsIJK
       );
 
+      const modalityUnitOptions = {
+        isPreScaled: isViewportPreScaled(viewport, targetId),
+        isSuvScaled: this.isSuvScaled(
+          viewport,
+          targetId,
+          annotation.metadata.referencedImageId
+        ),
+      };
+
       const modalityUnit = getModalityUnit(
         metadata.Modality,
         annotation.metadata.referencedImageId,

package/src/tools/annotation/ProbeTool.ts

@@ -442,36 +442,19 @@ class ProbeTool extends AnnotationTool {
 
       const color = this.getStyle('color', styleSpecifier, annotation);
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
-      if (!data.cachedStats[targetId]) {
+      if (
+        !data.cachedStats[targetId] ||
+        data.cachedStats[targetId].value == null
+      ) {
         data.cachedStats[targetId] = {
           Modality: null,
           index: null,
           value: null,
         };
 
-        this._calculateCachedStats(
-          annotation,
-          renderingEngine,
-          enabledElement,
-          modalityUnitOptions
-        );
+        this._calculateCachedStats(annotation, renderingEngine, enabledElement);
       } else if (annotation.invalidated) {
-        this._calculateCachedStats(
-          annotation,
-          renderingEngine,
-          enabledElement,
-          modalityUnitOptions
-        );
+        this._calculateCachedStats(annotation, renderingEngine, enabledElement);
 
         // If the invalidated data is as a result of volumeViewport manipulation
         // of the tools, we need to invalidate the related stackViewports data if
@@ -554,14 +537,9 @@ class ProbeTool extends AnnotationTool {
     return renderStatus;
   };
 
-  _calculateCachedStats(
-    annotation,
-    renderingEngine,
-    enabledElement,
-    modalityUnitOptions: ModalityUnitOptions
-  ) {
+  _calculateCachedStats(annotation, renderingEngine, enabledElement) {
     const data = annotation.data;
-    const { viewportId, renderingEngineId } = enabledElement;
+    const { viewportId, renderingEngineId, viewport } = enabledElement;
 
     const worldPos = data.handles.points[0];
     const { cachedStats } = data;
@@ -571,6 +549,15 @@ class ProbeTool extends AnnotationTool {
     for (let i = 0; i < targetIds.length; i++) {
       const targetId = targetIds[i];
 
+      const modalityUnitOptions = {
+        isPreScaled: isViewportPreScaled(viewport, targetId),
+        isSuvScaled: this.isSuvScaled(
+          viewport,
+          targetId,
+          annotation.metadata.referencedImageId
+        ),
+      };
+
       const image = this.getTargetIdImage(targetId, renderingEngine);
 
       // If image does not exists for the targetId, skip. This can be due

package/src/tools/annotation/RectangleROITool.ts

@@ -45,7 +45,6 @@ import {
   TextBoxHandle,
   ToolProps,
   PublicToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { RectangleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
@@ -659,21 +658,11 @@ class RectangleROITool extends AnnotationTool {
 
       const { viewPlaneNormal, viewUp } = viewport.getCamera();
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
       // If cachedStats does not exist, or the unit is missing (as part of import/hydration etc.),
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].areaUnit === undefined
+        data.cachedStats[targetId].areaUnit == null
       ) {
         data.cachedStats[targetId] = {
           Modality: null,
@@ -689,8 +678,7 @@ class RectangleROITool extends AnnotationTool {
           viewPlaneNormal,
           viewUp,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
       } else if (annotation.invalidated) {
         this._throttledCalculateCachedStats(
@@ -698,8 +686,7 @@ class RectangleROITool extends AnnotationTool {
           viewPlaneNormal,
           viewUp,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
 
         // If the invalidated data is as a result of volumeViewport manipulation
@@ -881,11 +868,10 @@ class RectangleROITool extends AnnotationTool {
     viewPlaneNormal,
     viewUp,
     renderingEngine,
-    enabledElement,
-    modalityUnitOptions
+    enabledElement
   ) => {
     const { data } = annotation;
-    const { viewportId, renderingEngineId } = enabledElement;
+    const { viewportId, renderingEngineId, viewport } = enabledElement;
 
     const worldPos1 = data.handles.points[0];
     const worldPos2 = data.handles.points[3];
@@ -954,6 +940,16 @@ class RectangleROITool extends AnnotationTool {
 
         const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
 
+        const modalityUnitOptions = {
+          isPreScaled: isViewportPreScaled(viewport, targetId),
+
+          isSuvScaled: this.isSuvScaled(
+            viewport,
+            targetId,
+            annotation.metadata.referencedImageId
+          ),
+        };
+
         const modalityUnit = getModalityUnit(
           metadata.Modality,
           annotation.metadata.referencedImageId,

package/src/tools/base/AnnotationDisplayTool.ts

@@ -102,6 +102,10 @@ abstract class AnnotationDisplayTool extends BaseTool {
 
       // for this specific tool
       toolSpecificAnnotations.forEach((annotation) => {
+        if (!annotation.metadata?.referencedImageId) {
+          return;
+        }
+
         // if the annotation is drawn on the same imageId
         const referencedImageURI = utilities.imageIdToURI(
           annotation.metadata.referencedImageId

package/src/tools/base/AnnotationTool.ts

@@ -94,7 +94,8 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
   abstract toolSelectedCallback(
     evt: EventTypes.InteractionEventType,
     annotation: Annotation,
-    interactionType: InteractionTypes
+    interactionType: InteractionTypes,
+    canvasCoords?: Types.Point2
   ): void;
 
   /**

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -2,6 +2,7 @@ import {
   getEnabledElementByIds,
   Types,
   utilities as csUtils,
+  StackViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
@@ -128,6 +129,13 @@ async function render(
   const contourData = segmentation.representationData[Representations.Contour];
   const { geometryIds } = contourData;
 
+
+  // We don't have a good way to handle stack viewports for contours at the moment.
+  // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
+  if (viewport instanceof StackViewport) {
+    return;
+  }
+
   if (!geometryIds?.length) {
     console.warn(
       `No contours found for segmentationId ${segmentationId}. Skipping render.`

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

@@ -416,7 +416,7 @@ function _needsTransferFunctionUpdate(
       renderFill,
       renderOutline,
       outlineWidth,
-      segmentColor,
+      segmentColor: segmentColor.slice(), // Create a copy
       segmentsHidden: new Set(segmentsHidden), // Create a copy
     });
 

package/src/tools/index.ts

@@ -10,7 +10,9 @@ import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
 import CrosshairsTool from './CrosshairsTool';
 import MagnifyTool from './MagnifyTool';
+import AdvancedMagnifyTool from './AdvancedMagnifyTool';
 import ReferenceLinesTool from './ReferenceLinesTool';
+import OverlayGridTool from './OverlayGridTool';
 //
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
@@ -38,6 +40,7 @@ import RectangleROIThresholdTool from './segmentation/RectangleROIThresholdTool'
 import RectangleROIStartEndThresholdTool from './segmentation/RectangleROIStartEndThresholdTool';
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
+import OrientationMarkerTool from './OrientationMarkerTool';
 
 export {
   // ~~ BASE
@@ -58,6 +61,7 @@ export {
   // Annotation Tools
   CrosshairsTool,
   ReferenceLinesTool,
+  OverlayGridTool,
   BidirectionalTool,
   LengthTool,
   ProbeTool,
@@ -79,7 +83,9 @@ export {
   RectangleROIStartEndThresholdTool,
   BrushTool,
   MagnifyTool,
+  AdvancedMagnifyTool,
   ReferenceLines,
   PaintFillTool,
   ScaleOverlayTool,
+  OrientationMarkerTool,
 };

package/src/types/EventTypes.ts

@@ -5,6 +5,7 @@ import ITouchPoints from './ITouchPoints';
 import IDistance from './IDistance';
 import { SetToolBindingsType } from './ISetToolModeOptions';
 import { Swipe } from '../enums/Touch';
+import { ToolModes } from '../enums';
 
 /**
  * The normalized interaction event detail
@@ -71,6 +72,20 @@ type InteractionStartEventDetail = InteractionEventDetail;
 
 type InteractionEndEventDetail = InteractionEventDetail;
 
+/**
+ * The data that is passed to the event handler when tool mode changes
+ */
+type ToolModeChangedEventDetail = {
+  /** unique id of the toolGroup */
+  toolGroupId: string;
+  /** Tool name */
+  toolName: string;
+  /** Tool mode */
+  mode: ToolModes;
+  /** Tool binding options */
+  toolBindingsOptions?: SetToolBindingsType;
+};
+
 /**
  * The data that is passed to the event handler when a tool is activated.
  */
@@ -424,6 +439,12 @@ type NormalizedMouseEventType = Types.CustomEventType<MouseCustomEventDetail>;
  */
 type NormalizedTouchEventType = Types.CustomEventType<TouchCustomEventDetail>;
 
+/**
+ * The ToolModeChanged event type
+ */
+type ToolModeChangedEventType =
+  Types.CustomEventType<ToolModeChangedEventDetail>;
+
 /**
  * The ToolActivated event type
  */
@@ -629,6 +650,8 @@ export {
   NormalizedInteractionEventDetail,
   NormalizedMouseEventType,
   NormalizedTouchEventType,
+  ToolModeChangedEventDetail,
+  ToolModeChangedEventType,
   ToolActivatedEventDetail,
   ToolActivatedEventType,
   AnnotationAddedEventDetail,

package/src/types/IToolGroup.ts

@@ -75,4 +75,11 @@ export default interface IToolGroup {
   getDefaultMousePrimary: {
     (): MouseBindings;
   };
+
+  clone: {
+    (
+      newToolGroupId: string,
+      fnToolFilter: (toolName: string) => boolean
+    ): IToolGroup;
+  };
 }

package/src/types/ToolAction.ts

@@ -0,0 +1,54 @@
+import type { Annotation } from './AnnotationTypes';
+import type { InteractionEventType } from './EventTypes';
+import type { SetToolBindingsType } from './ISetToolModeOptions';
+
+/**
+ * An action that may be defined at the tool configuration level
+ *
+ * Annotations can have actions that run a specific task (ex: showing a dropdown
+ * containing a list of all predefined zoom levels - advanced magnifier glass).
+ * Each action must have at least one binding option (mouse button + [modifier(s)])
+ * and a action runs if and only if no other tool is using that same binding options
+ * to draw an annotation because action has lower priority.
+ *
+ * Actions are defined in the following way in a annotation tool constructor:
+ *
+ * class MyAnnotationTool extends AnnotationTool {
+ *   constructor(
+ *     toolProps: PublicToolProps = {},
+ *     defaultToolProps: ToolProps = {
+ *       configuration: {
+ *         actions: [
+ *           {
+ *             method: 'myAction',
+ *             bindings: [
+ *               {
+ *                 mouseButton: MouseBindings.Secondary,
+ *                 modifierKey: KeyboardBindings.Shift,
+ *               }
+ *             ]
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   ) {
+ *     super(toolProps, defaultToolProps);
+ *   }
+ *
+ *   public myAction(evt: EventTypes.InteractionEventType, annotation: MyAnnotation) {
+ *     // action code
+ *   }
+ * }
+ *
+ * The "method" property may be a string or a javascript function. In case it is
+ * a string a function with same name must exists in the tool class. In both ways
+ * (string or function) the function is called in the tool's context (`this`)
+ */
+type ToolAction = {
+  method:
+    | string
+    | ((evt: InteractionEventType, annotation: Annotation) => void);
+  bindings: SetToolBindingsType[];
+};
+
+export default ToolAction;