@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.8

package/src/tools/annotation/CobbAngleTool.ts

@@ -1,10 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import { Events } from '../../enums';
-import {
-  getEnabledElement,
-  triggerEvent,
-  eventTarget,
-} from '@cornerstonejs/core';
+import { getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { AnnotationTool } from '../base';
@@ -15,6 +11,10 @@ import {
   removeAnnotation,
 } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import {
+  triggerAnnotationCompleted,
+  triggerAnnotationModified,
+} from '../../stateManagement/annotation/helpers/state';
 import * as lineSegment from '../../utilities/math/line';
 import angleBetweenLines from '../../utilities/math/angle/angleBetweenLines';
 import { midPoint2 } from '../../utilities/math/midPoint';
@@ -29,10 +29,6 @@ import { state } from '../../store';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import {
-  AnnotationCompletedEventDetail,
-  AnnotationModifiedEventDetail,
-} from '../../types/EventTypes';
 
 import {
   resetElementCursor,
@@ -79,6 +75,7 @@ class CobbAngleTool extends AnnotationTool {
         shadow: true,
         preventHandleOutsideImage: false,
         getTextLines: defaultGetTextLines,
+        showArcLines: false,
       },
     }
   ) {
@@ -137,6 +134,7 @@ class CobbAngleTool extends AnnotationTool {
         viewUp: <Types.Point3>[...viewUp],
         FrameOfReferenceUID,
         referencedImageId,
+        ...viewport.getViewReference({ points: [worldPos] }),
       },
       data: {
         handles: {
@@ -352,13 +350,7 @@ class CobbAngleTool extends AnnotationTool {
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
 
     if (newAnnotation) {
-      const eventType = Events.ANNOTATION_COMPLETED;
-
-      const eventDetail: AnnotationCompletedEventDetail = {
-        annotation,
-      };
-
-      triggerEvent(eventTarget, eventType, eventDetail);
+      triggerAnnotationCompleted(annotation);
     }
 
     this.editData = null;
@@ -513,13 +505,7 @@ class CobbAngleTool extends AnnotationTool {
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
 
     if (newAnnotation) {
-      const eventType = Events.ANNOTATION_COMPLETED;
-
-      const eventDetail: AnnotationCompletedEventDetail = {
-        annotation,
-      };
-
-      triggerEvent(eventTarget, eventType, eventDetail);
+      triggerAnnotationCompleted(annotation);
     }
 
     this.editData = null;
@@ -673,9 +659,10 @@ class CobbAngleTool extends AnnotationTool {
 
       styleSpecifier.annotationUID = annotationUID;
 
-      const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-      const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-      const color = this.getStyle('color', styleSpecifier, annotation);
+      const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+        annotation,
+        styleSpecifier,
+      });
 
       const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
 
@@ -810,33 +797,35 @@ class CobbAngleTool extends AnnotationTool {
         data.cachedStats[targetId].points.canvas;
       const { arc1Angle, arc2Angle } = data.cachedStats[targetId];
 
-      lineUID = 'arc1';
+      if (this.configuration.showArcLines) {
+        lineUID = 'arc1';
 
-      drawLineSvg(
-        svgDrawingHelper,
-        annotationUID,
-        lineUID,
-        arc1Start as Types.Point2,
-        arc1End as Types.Point2,
-        {
-          color,
-          lineWidth: '1',
-        }
-      );
+        drawLineSvg(
+          svgDrawingHelper,
+          annotationUID,
+          lineUID,
+          arc1Start as Types.Point2,
+          arc1End as Types.Point2,
+          {
+            color,
+            lineWidth: '1',
+          }
+        );
 
-      lineUID = 'arc2';
+        lineUID = 'arc2';
 
-      drawLineSvg(
-        svgDrawingHelper,
-        annotationUID,
-        lineUID,
-        arc2Start as Types.Point2,
-        arc2End as Types.Point2,
-        {
-          color,
-          lineWidth: '1',
-        }
-      );
+        drawLineSvg(
+          svgDrawingHelper,
+          annotationUID,
+          lineUID,
+          arc2Start as Types.Point2,
+          arc2End as Types.Point2,
+          {
+            color,
+            lineWidth: '1',
+          }
+        );
+      }
 
       if (!data.cachedStats[targetId]?.angle) {
         continue;
@@ -891,45 +880,47 @@ class CobbAngleTool extends AnnotationTool {
         bottomRight: viewport.canvasToWorld([left + width, top + height]),
       };
 
-      const arc1TextBoxUID = 'arcAngle1';
+      if (this.configuration.showArcLines) {
+        const arc1TextBoxUID = 'arcAngle1';
 
-      const arc1TextLine = [
-        `${arc1Angle.toFixed(2)} ${String.fromCharCode(176)}`,
-      ];
+        const arc1TextLine = [
+          `${arc1Angle.toFixed(2)} ${String.fromCharCode(176)}`,
+        ];
 
-      const arch1TextPosCanvas = midPoint2(arc1Start, arc1End);
+        const arch1TextPosCanvas = midPoint2(arc1Start, arc1End);
 
-      drawTextBoxSvg(
-        svgDrawingHelper,
-        annotationUID,
-        arc1TextBoxUID,
-        arc1TextLine,
-        arch1TextPosCanvas,
-        {
-          ...options,
-          padding: 3,
-        }
-      );
+        drawTextBoxSvg(
+          svgDrawingHelper,
+          annotationUID,
+          arc1TextBoxUID,
+          arc1TextLine,
+          arch1TextPosCanvas,
+          {
+            ...options,
+            padding: 3,
+          }
+        );
 
-      const arc2TextBoxUID = 'arcAngle2';
+        const arc2TextBoxUID = 'arcAngle2';
 
-      const arc2TextLine = [
-        `${arc2Angle.toFixed(2)} ${String.fromCharCode(176)}`,
-      ];
+        const arc2TextLine = [
+          `${arc2Angle.toFixed(2)} ${String.fromCharCode(176)}`,
+        ];
 
-      const arch2TextPosCanvas = midPoint2(arc2Start, arc2End);
+        const arch2TextPosCanvas = midPoint2(arc2Start, arc2End);
 
-      drawTextBoxSvg(
-        svgDrawingHelper,
-        annotationUID,
-        arc2TextBoxUID,
-        arc2TextLine,
-        arch2TextPosCanvas,
-        {
-          ...options,
-          padding: 3,
-        }
-      );
+        drawTextBoxSvg(
+          svgDrawingHelper,
+          annotationUID,
+          arc2TextBoxUID,
+          arc2TextLine,
+          arch2TextPosCanvas,
+          {
+            ...options,
+            padding: 3,
+          }
+        );
+      }
     }
 
     return renderStatus;
@@ -937,7 +928,6 @@ class CobbAngleTool extends AnnotationTool {
 
   _calculateCachedStats(annotation, renderingEngine, enabledElement) {
     const data = annotation.data;
-    const { viewportId, renderingEngineId } = enabledElement;
 
     // Until we have all four anchors bail out
     if (data.handles.points.length !== 4) {
@@ -972,6 +962,7 @@ class CobbAngleTool extends AnnotationTool {
       }
     }
     const { viewport } = enabledElement;
+    const { element } = viewport;
 
     const canvasPoints = data.handles.points.map((p) =>
       viewport.worldToCanvas(p)
@@ -1027,14 +1018,7 @@ class CobbAngleTool extends AnnotationTool {
     annotation.invalidated = false;
 
     // Dispatching annotation modified
-    const eventType = Events.ANNOTATION_MODIFIED;
-
-    const eventDetail: AnnotationModifiedEventDetail = {
-      annotation,
-      viewportId,
-      renderingEngineId,
-    };
-    triggerEvent(eventTarget, eventType, eventDetail);
+    triggerAnnotationModified(annotation, element);
 
     return cachedStats;
   }

package/src/tools/annotation/DragProbeTool.ts

@@ -154,7 +154,10 @@ class DragProbeTool extends ProbeTool {
 
     styleSpecifier.annotationUID = annotationUID;
 
-    const color = this.getStyle('color', styleSpecifier, annotation);
+    const { color } = this.getAnnotationStyle({
+      annotation,
+      styleSpecifier,
+    });
 
     const modalityUnitOptions = {
       isPreScaled: isViewportPreScaled(viewport, targetId),

package/src/tools/annotation/EllipticalROITool.ts

@@ -3,17 +3,12 @@ import { AnnotationTool } from '../base';
 import {
   getEnabledElement,
   VolumeViewport,
-  eventTarget,
-  triggerEvent,
   utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import {
-  getCalibratedAreaUnits,
-  getCalibratedScale,
-} from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import {
   addAnnotation,
@@ -22,9 +17,13 @@ import {
 } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
+import {
+  triggerAnnotationCompleted,
+  triggerAnnotationModified,
+} from '../../stateManagement/annotation/helpers/state';
 import {
   drawCircle as drawCircleSvg,
-  drawEllipse as drawEllipseSvg,
+  drawEllipseByCoordinates as drawEllipseSvg,
   drawHandles as drawHandlesSvg,
   drawLinkedTextBox as drawLinkedTextBoxSvg,
 } from '../../drawingSvg';
@@ -51,17 +50,10 @@ import {
 } from '../../types';
 import { EllipticalROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 
-import {
-  AnnotationCompletedEventDetail,
-  AnnotationModifiedEventDetail,
-} from '../../types/EventTypes';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { pointInShapeCallback } from '../../utilities/';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
-import {
-  ModalityUnitOptions,
-  getModalityUnit,
-} from '../../utilities/getModalityUnit';
+import { getModalityUnit } from '../../utilities/getModalityUnit';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 
@@ -201,6 +193,7 @@ class EllipticalROITool extends AnnotationTool {
         viewUp: <Types.Point3>[...viewUp],
         FrameOfReferenceUID,
         referencedImageId,
+        ...viewport.getViewReference({ points: [worldPos] }),
       },
       data: {
         label: '',
@@ -446,8 +439,7 @@ class EllipticalROITool extends AnnotationTool {
 
     resetElementCursor(element);
 
-    const enabledElement = getEnabledElement(element);
-    const { renderingEngine } = enabledElement;
+    const { renderingEngine } = getEnabledElement(element);
 
     this.editData = null;
     this.isDrawing = false;
@@ -462,13 +454,7 @@ class EllipticalROITool extends AnnotationTool {
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
 
     if (newAnnotation) {
-      const eventType = Events.ANNOTATION_COMPLETED;
-
-      const eventDetail: AnnotationCompletedEventDetail = {
-        annotation,
-      };
-
-      triggerEvent(eventTarget, eventType, eventDetail);
+      triggerAnnotationCompleted(annotation);
     }
   };
 
@@ -652,8 +638,7 @@ class EllipticalROITool extends AnnotationTool {
       annotation.highlighted = false;
       data.handles.activeHandleIndex = null;
 
-      const enabledElement = getEnabledElement(element);
-      const { renderingEngine } = enabledElement;
+      const { renderingEngine } = getEnabledElement(element);
 
       triggerAnnotationRenderForViewportIds(
         renderingEngine,
@@ -661,13 +646,7 @@ class EllipticalROITool extends AnnotationTool {
       );
 
       if (newAnnotation) {
-        const eventType = Events.ANNOTATION_COMPLETED;
-
-        const eventDetail: AnnotationCompletedEventDetail = {
-          annotation,
-        };
-
-        triggerEvent(eventTarget, eventType, eventDetail);
+        triggerAnnotationCompleted(annotation);
       }
 
       this.editData = null;
@@ -774,9 +753,10 @@ class EllipticalROITool extends AnnotationTool {
 
       styleSpecifier.annotationUID = annotationUID;
 
-      const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-      const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-      const color = this.getStyle('color', styleSpecifier, annotation);
+      const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+        annotation,
+        styleSpecifier,
+      });
 
       const canvasCoordinates = points.map((p) =>
         viewport.worldToCanvas(p)
@@ -785,23 +765,11 @@ class EllipticalROITool extends AnnotationTool {
       const rotation = Math.abs(
         viewport.getRotation() - (data.initialRotation || 0)
       );
-      let canvasCorners;
-
-      if (rotation == 90 || rotation == 270) {
-        canvasCorners = <Array<Types.Point2>>getCanvasEllipseCorners([
-          canvasCoordinates[2], // bottom
-          canvasCoordinates[3], // top
-          canvasCoordinates[0], // left
-          canvasCoordinates[1], // right
-        ]);
-      } else {
-        canvasCorners = <Array<Types.Point2>>(
-          getCanvasEllipseCorners(canvasCoordinates) // bottom, top, left, right, keep as is
-        );
-      }
+      const canvasCorners = <Array<Types.Point2>>(
+        getCanvasEllipseCorners(canvasCoordinates) // bottom, top, left, right, keep as is
+      );
 
       const { centerPointRadius } = this.configuration;
-
       // 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 (
@@ -817,12 +785,7 @@ class EllipticalROITool extends AnnotationTool {
           areaUnit: null,
         };
 
-        this._calculateCachedStats(
-          annotation,
-          viewport,
-          renderingEngine,
-          enabledElement
-        );
+        this._calculateCachedStats(annotation, viewport, renderingEngine);
       } else if (annotation.invalidated) {
         this._throttledCalculateCachedStats(
           annotation,
@@ -905,8 +868,7 @@ class EllipticalROITool extends AnnotationTool {
         svgDrawingHelper,
         annotationUID,
         ellipseUID,
-        canvasCorners[0],
-        canvasCorners[1],
+        canvasCoordinates,
         {
           color,
           lineDash,
@@ -999,14 +961,9 @@ class EllipticalROITool extends AnnotationTool {
     return renderStatus;
   };
 
-  _calculateCachedStats = (
-    annotation,
-    viewport,
-    renderingEngine,
-    enabledElement
-  ) => {
+  _calculateCachedStats = (annotation, viewport, renderingEngine) => {
     const data = annotation.data;
-    const { viewportId, renderingEngineId } = enabledElement;
+    const { element } = viewport;
 
     const { points } = data.handles;
 
@@ -1037,123 +994,118 @@ class EllipticalROITool extends AnnotationTool {
         continue;
       }
 
-      const { dimensions, imageData, metadata, hasPixelSpacing } = image;
+      const { dimensions, imageData, metadata } = image;
 
-      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 post2Index = transformWorldToIndex(imageData, worldPos2);
 
-      worldPos2Index[0] = Math.floor(worldPos2Index[0]);
-      worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-      worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+      post2Index[0] = Math.floor(post2Index[0]);
+      post2Index[1] = Math.floor(post2Index[1]);
+      post2Index[2] = Math.floor(post2Index[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)) {
-        const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
-        const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
-
-        const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);
-        const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
-
-        const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
-        const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
-
-        const boundsIJK = [
-          [iMin, iMax],
-          [jMin, jMax],
-          [kMin, kMax],
-        ] as [Types.Point2, Types.Point2, Types.Point2];
-
-        const center = [
-          (topLeftWorld[0] + bottomRightWorld[0]) / 2,
-          (topLeftWorld[1] + bottomRightWorld[1]) / 2,
-          (topLeftWorld[2] + bottomRightWorld[2]) / 2,
-        ] as Types.Point3;
-
-        const ellipseObj = {
-          center,
-          xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-          yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-          zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-        };
+      this.isHandleOutsideImage = !this._isInsideVolume(
+        pos1Index,
+        post2Index,
+        dimensions
+      );
 
-        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(
-          viewPlaneNormal,
-          viewUp,
-          worldPos1,
-          worldPos2
-        );
-        const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-        const scale = getCalibratedScale(image);
-        const area =
-          Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-          scale /
-          scale;
-
-        const modalityUnitOptions = {
-          isPreScaled: isViewportPreScaled(viewport, targetId),
-
-          isSuvScaled: this.isSuvScaled(
-            viewport,
-            targetId,
-            annotation.metadata.referencedImageId
-          ),
-        };
+      const iMin = Math.min(pos1Index[0], post2Index[0]);
+      const iMax = Math.max(pos1Index[0], post2Index[0]);
 
-        const modalityUnit = getModalityUnit(
-          metadata.Modality,
-          annotation.metadata.referencedImageId,
-          modalityUnitOptions
-        );
+      const jMin = Math.min(pos1Index[1], post2Index[1]);
+      const jMax = Math.max(pos1Index[1], post2Index[1]);
 
-        const pointsInShape = pointInShapeCallback(
-          imageData,
-          (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS),
-          this.configuration.statsCalculator.statsCallback,
-          boundsIJK
-        );
+      const kMin = Math.min(pos1Index[2], post2Index[2]);
+      const kMax = Math.max(pos1Index[2], post2Index[2]);
 
-        const stats = this.configuration.statsCalculator.getStatistics();
-
-        cachedStats[targetId] = {
-          Modality: metadata.Modality,
-          area,
-          mean: stats[1]?.value,
-          max: stats[0]?.value,
-          stdDev: stats[2]?.value,
-          statsArray: stats,
-          pointsInShape: pointsInShape,
-          isEmptyArea,
-          areaUnit: getCalibratedAreaUnits(null, image),
-          modalityUnit,
-        };
-      } else {
-        this.isHandleOutsideImage = true;
+      const boundsIJK = [
+        [iMin, iMax],
+        [jMin, jMax],
+        [kMin, kMax],
+      ] as [Types.Point2, Types.Point2, Types.Point2];
 
-        cachedStats[targetId] = {
-          Modality: metadata.Modality,
-        };
-      }
+      const center = [
+        (topLeftWorld[0] + bottomRightWorld[0]) / 2,
+        (topLeftWorld[1] + bottomRightWorld[1]) / 2,
+        (topLeftWorld[2] + bottomRightWorld[2]) / 2,
+      ] as Types.Point3;
+
+      const ellipseObj = {
+        center,
+        xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
+        yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
+        zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
+      };
+
+      const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(
+        viewPlaneNormal,
+        viewUp,
+        worldPos1,
+        worldPos2
+      );
+      const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+
+      const handles = [pos1Index, post2Index];
+      const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(
+        image,
+        handles
+      );
+
+      const area =
+        Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
+        scale /
+        scale;
+
+      const modalityUnitOptions = {
+        isPreScaled: isViewportPreScaled(viewport, targetId),
+
+        isSuvScaled: this.isSuvScaled(
+          viewport,
+          targetId,
+          annotation.metadata.referencedImageId
+        ),
+      };
+
+      const modalityUnit = getModalityUnit(
+        metadata.Modality,
+        annotation.metadata.referencedImageId,
+        modalityUnitOptions
+      );
+
+      const pointsInShape = pointInShapeCallback(
+        imageData,
+        (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }),
+        this.configuration.statsCalculator.statsCallback,
+        boundsIJK
+      );
+
+      const stats = this.configuration.statsCalculator.getStatistics();
+      cachedStats[targetId] = {
+        Modality: metadata.Modality,
+        area,
+        mean: stats.mean?.value,
+        max: stats.max?.value,
+        stdDev: stats.stdDev?.value,
+        statsArray: stats.array,
+        pointsInShape,
+        isEmptyArea,
+        areaUnit: areaUnits,
+        modalityUnit,
+      };
     }
 
     annotation.invalidated = false;
 
     // Dispatching annotation modified
-    const eventType = Events.ANNOTATION_MODIFIED;
-
-    const eventDetail: AnnotationModifiedEventDetail = {
-      annotation,
-      viewportId,
-      renderingEngineId,
-    };
-
-    triggerEvent(eventTarget, eventType, eventDetail);
+    triggerAnnotationModified(annotation, element);
 
     return cachedStats;
   };