@cornerstonejs/tools 1.43.6 → 1.44.0

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -15,11 +15,6 @@ import {
 } from '../../utilities/getCalibratedUnits';
 import { roundNumber } from '../../utilities';
 import { Events } from '../../enums';
-import { AnnotationTool } from '../base';
-import {
-  addAnnotation,
-  getAnnotations,
-} from '../../stateManagement/annotation/annotationState';
 import { polyline } from '../../utilities/math';
 import { filterAnnotationsForDisplay } from '../../utilities/planar';
 import throttle from '../../utilities/throttle';
@@ -53,11 +48,9 @@ import { PlanarFreehandROICommonData } from '../../utilities/math/polyline/plana
 import { getIntersectionCoordinatesWithPolyline } from '../../utilities/math/polyline/getIntersectionWithPolyline';
 import pointInShapeCallback from '../../utilities/pointInShapeCallback';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
-import {
-  ModalityUnitOptions,
-  getModalityUnit,
-} from '../../utilities/getModalityUnit';
+import { getModalityUnit } from '../../utilities/getModalityUnit';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
+import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
@@ -121,10 +114,11 @@ const PARALLEL_THRESHOLD = 1 - EPSILON;
  * });
  * ```
  *
+ *
  * Read more in the Docs section of the website.
  */
 
-class PlanarFreehandROITool extends AnnotationTool {
+class PlanarFreehandROITool extends ContourSegmentationBaseTool {
   static toolName;
 
   public touchDragCallback: any;
@@ -249,63 +243,23 @@ class PlanarFreehandROITool extends AnnotationTool {
     evt: EventTypes.InteractionEventType
   ): PlanarFreehandROIAnnotation => {
     const eventDetail = evt.detail;
-    const { currentPoints, element } = eventDetail;
-    const worldPos = currentPoints.world;
+    const { element } = eventDetail;
     const enabledElement = getEnabledElement(element);
-    const { viewport, renderingEngine } = enabledElement;
-    const camera = viewport.getCamera();
-    const { viewPlaneNormal, viewUp } = camera;
+    const { renderingEngine } = enabledElement;
+
+    const annotation = this.createAnnotation(
+      evt
+    ) as PlanarFreehandROIAnnotation;
+
+    this.addAnnotation(annotation, element);
 
-    const referencedImageId = this.getReferencedImageId(
-      viewport,
-      worldPos,
-      viewPlaneNormal,
-      viewUp
-    );
     const viewportIdsToRender = getViewportIdsWithToolToRender(
       element,
       this.getToolName()
     );
 
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-
-    const annotation: PlanarFreehandROIAnnotation = {
-      highlighted: true,
-      invalidated: true,
-      metadata: {
-        viewPlaneNormal: <Types.Point3>[...viewPlaneNormal],
-        viewUp: <Types.Point3>[...viewUp],
-        FrameOfReferenceUID,
-        referencedImageId,
-        toolName: this.getToolName(),
-      },
-      data: {
-        handles: {
-          points: [], // Handle points for open contours
-          activeHandleIndex: null,
-          textBox: {
-            hasMoved: false,
-            worldPosition: <Types.Point3>[0, 0, 0],
-            worldBoundingBox: {
-              topLeft: <Types.Point3>[0, 0, 0],
-              topRight: <Types.Point3>[0, 0, 0],
-              bottomLeft: <Types.Point3>[0, 0, 0],
-              bottomRight: <Types.Point3>[0, 0, 0],
-            },
-          },
-        },
-        polyline: [<Types.Point3>[...worldPos]], // Polyline coordinates
-        label: '',
-        cachedStats: {},
-      },
-    };
-
-    addAnnotation(annotation, element);
-
     this.activateDraw(evt, annotation, viewportIdsToRender);
-
     evt.preventDefault();
-
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
 
     return annotation;
@@ -356,10 +310,10 @@ class PlanarFreehandROITool extends AnnotationTool {
       this.getToolName()
     );
 
-    if (annotation.data.isOpenContour) {
-      this.activateOpenContourEdit(evt, annotation, viewportIdsToRender);
-    } else {
+    if (annotation.data.contour.closed) {
       this.activateClosedContourEdit(evt, annotation, viewportIdsToRender);
+    } else {
+      this.activateOpenContourEdit(evt, annotation, viewportIdsToRender);
     }
   };
 
@@ -383,7 +337,7 @@ class PlanarFreehandROITool extends AnnotationTool {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
 
-    const points = annotation.data.polyline;
+    const points = annotation.data.contour.polyline;
 
     // NOTE: It is implemented this way so that we do not double calculate
     // points when number crunching adjacent line segments.
@@ -392,17 +346,16 @@ class PlanarFreehandROITool extends AnnotationTool {
     for (let i = 1; i < points.length; i++) {
       const p1 = previousPoint;
       const p2 = viewport.worldToCanvas(points[i]);
+      const canProject = pointCanProjectOnLine(canvasCoords, p1, p2, proximity);
 
-      const distance = pointCanProjectOnLine(canvasCoords, p1, p2, proximity);
-
-      if (distance === true) {
+      if (canProject) {
         return true;
       }
 
       previousPoint = p2;
     }
 
-    if (annotation.data.isOpenContour) {
+    if (!annotation.data.contour.closed) {
       // Contour is open, don't check last point to first point.
       return false;
     }
@@ -411,18 +364,7 @@ class PlanarFreehandROITool extends AnnotationTool {
     const pStart = viewport.worldToCanvas(points[0]);
     const pEnd = viewport.worldToCanvas(points[points.length - 1]);
 
-    const distance = pointCanProjectOnLine(
-      canvasCoords,
-      pStart,
-      pEnd,
-      proximity
-    );
-
-    if (distance === true) {
-      return true;
-    }
-
-    return false;
+    return pointCanProjectOnLine(canvasCoords, pStart, pEnd, proximity);
   };
 
   cancel = (element: HTMLDivElement): void => {
@@ -534,7 +476,7 @@ class PlanarFreehandROITool extends AnnotationTool {
 
         return annotationViewPlaneNormal && isParallel;
       }
-    );
+    ) as PlanarFreehandROIAnnotation[];
 
     // No in plane annotations.
     if (!annotationsWithParallelNormals.length) {
@@ -551,7 +493,7 @@ class PlanarFreehandROITool extends AnnotationTool {
 
     for (const annotation of annotationsWithParallelNormals) {
       const data = annotation.data;
-      const point = data.polyline[0];
+      const point = data.contour.polyline[0];
 
       if (!annotation.isVisible) {
         continue;
@@ -578,39 +520,46 @@ class PlanarFreehandROITool extends AnnotationTool {
     return annotationsWithinSlice;
   }
 
-  /**
-   * Draws the `PlanarFreehandROIAnnotation`s at each request animation frame.
-   *
-   * @param enabledElement - The Cornerstone's enabledElement.
-   * @param svgDrawingHelper - The svgDrawingHelper providing the context for drawing.
-   */
-  renderAnnotation = (
-    enabledElement: Types.IEnabledElement,
-    svgDrawingHelper: SVGDrawingHelper
-  ): boolean => {
-    let renderStatus = false;
-    const { viewport, renderingEngine } = enabledElement;
-    const { element } = viewport;
+  protected isContourSegmentationTool(): boolean {
+    // Disable contour segmenatation behavior because it shall be activated only
+    // for PlanarFreehandContourSegmentationTool
+    return false;
+  }
 
-    const targetId = this.getTargetId(viewport);
+  protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation {
+    const worldPos = evt.detail.currentPoints.world;
+    const contourAnnotation = super.createAnnotation(evt);
 
-    let annotations = <PlanarFreehandROIAnnotation[]>(
-      getAnnotations(this.getToolName(), element)
-    );
+    return <PlanarFreehandROIAnnotation>csUtils.deepMerge(contourAnnotation, {
+      data: {
+        contour: {
+          polyline: [<Types.Point3>[...worldPos]],
+        },
+        label: '',
+        cachedStats: {},
+      },
+    });
+  }
 
-    // Todo: We don't need this anymore, filtering happens in triggerAnnotationRender
-    if (!annotations?.length) {
-      return renderStatus;
-    }
+  protected getAnnotationStyle(context) {
+    // This method exists only because `super` cannot be called from
+    // _getRenderingOptions() which is in an external file.
+    return super.getAnnotationStyle(context);
+  }
 
-    annotations = this.filterInteractableAnnotationsForElement(
-      element,
-      annotations
-    ) as PlanarFreehandROIAnnotation[];
+  protected renderAnnotationInstance(renderContext: {
+    enabledElement: Types.IEnabledElement;
+    targetId: string;
+    annotation: Annotation;
+    annotationStyle: Record<string, any>;
+    svgDrawingHelper: SVGDrawingHelper;
+  }): boolean {
+    const { enabledElement, targetId, svgDrawingHelper, annotationStyle } =
+      renderContext;
+    const annotation = renderContext.annotation as PlanarFreehandROIAnnotation;
 
-    if (!annotations?.length) {
-      return renderStatus;
-    }
+    let renderStatus = false;
+    const { viewport, renderingEngine } = enabledElement;
 
     const isDrawing = this.isDrawing;
     const isEditingOpen = this.isEditingOpen;
@@ -619,44 +568,40 @@ class PlanarFreehandROITool extends AnnotationTool {
     if (!(isDrawing || isEditingOpen || isEditingClosed)) {
       // No annotations are currently being modified, so we can just use the
       // render contour method to render all of them
-      annotations.forEach((annotation) => {
-        this.renderContour(enabledElement, svgDrawingHelper, annotation);
-      });
+      this.renderContour(enabledElement, svgDrawingHelper, annotation);
     } else {
-      // One of the annotations will need special rendering treatment, render all
+      // The active annotation will need special rendering treatment. Render all
       // other annotations not being interacted with using the standard renderContour
       // rendering path.
       const activeAnnotationUID = this.commonData.annotation.annotationUID;
 
-      annotations.forEach((annotation) => {
-        if (annotation.annotationUID === activeAnnotationUID) {
-          if (isDrawing) {
-            this.renderContourBeingDrawn(
-              enabledElement,
-              svgDrawingHelper,
-              annotation
-            );
-          } else if (isEditingClosed) {
-            this.renderClosedContourBeingEdited(
-              enabledElement,
-              svgDrawingHelper,
-              annotation
-            );
-          } else if (isEditingOpen) {
-            this.renderOpenContourBeingEdited(
-              enabledElement,
-              svgDrawingHelper,
-              annotation
-            );
-          } else {
-            throw new Error(
-              `Unknown ${this.getToolName()} annotation rendering state`
-            );
-          }
+      if (annotation.annotationUID === activeAnnotationUID) {
+        if (isDrawing) {
+          this.renderContourBeingDrawn(
+            enabledElement,
+            svgDrawingHelper,
+            annotation
+          );
+        } else if (isEditingClosed) {
+          this.renderClosedContourBeingEdited(
+            enabledElement,
+            svgDrawingHelper,
+            annotation
+          );
+        } else if (isEditingOpen) {
+          this.renderOpenContourBeingEdited(
+            enabledElement,
+            svgDrawingHelper,
+            annotation
+          );
         } else {
-          this.renderContour(enabledElement, svgDrawingHelper, annotation);
+          throw new Error(
+            `Unknown ${this.getToolName()} annotation rendering state`
+          );
         }
-      });
+      } else {
+        this.renderContour(enabledElement, svgDrawingHelper, annotation);
+      }
 
       // Todo: return boolean flag for each rendering route in the planar tool.
       renderStatus = true;
@@ -666,60 +611,76 @@ class PlanarFreehandROITool extends AnnotationTool {
       return;
     }
 
-    annotations.forEach((annotation) => {
-      const activeAnnotationUID = this.commonData?.annotation.annotationUID;
-      if (
-        annotation.annotationUID === activeAnnotationUID &&
-        !this.commonData?.movingTextBox
-      ) {
-        return;
-      }
-
-      if (!this.commonData?.movingTextBox) {
-        const { data } = annotation;
-        if (
-          !data.cachedStats[targetId] ||
-          data.cachedStats[targetId].areaUnit == null
-        ) {
-          data.cachedStats[targetId] = {
-            Modality: null,
-            area: null,
-            max: null,
-            mean: null,
-            stdDev: null,
-            areaUnit: null,
-          };
-
-          this._calculateCachedStats(
-            annotation,
-            viewport,
-            renderingEngine,
-            enabledElement
-          );
-        } else if (annotation.invalidated) {
-          this._throttledCalculateCachedStats(
-            annotation,
-            viewport,
-            renderingEngine,
-            enabledElement
-          );
-        }
-      }
+    this._calculateStatsIfActive(
+      annotation,
+      targetId,
+      viewport,
+      renderingEngine,
+      enabledElement
+    );
 
-      this._renderStats(annotation, viewport, enabledElement, svgDrawingHelper);
-    });
+    this._renderStats(annotation, viewport, enabledElement, svgDrawingHelper);
 
     return renderStatus;
-  };
+  }
+
+  _calculateStatsIfActive(
+    annotation: PlanarFreehandROIAnnotation,
+    targetId: string,
+    viewport,
+    renderingEngine,
+    enabledElement
+  ) {
+    const activeAnnotationUID = this.commonData?.annotation.annotationUID;
+
+    if (
+      annotation.annotationUID === activeAnnotationUID &&
+      !this.commonData?.movingTextBox
+    ) {
+      return;
+    }
 
-  _calculateCachedStats = (
+    if (!this.commonData?.movingTextBox) {
+      const { data } = annotation;
+      if (
+        !data.cachedStats[targetId] ||
+        data.cachedStats[targetId].areaUnit == null
+      ) {
+        data.cachedStats[targetId] = {
+          Modality: null,
+          area: null,
+          max: null,
+          mean: null,
+          stdDev: null,
+          areaUnit: null,
+        };
+
+        this._calculateCachedStats(
+          annotation,
+          viewport,
+          renderingEngine,
+          enabledElement
+        );
+      } else if (annotation.invalidated) {
+        this._throttledCalculateCachedStats(
+          annotation,
+          viewport,
+          renderingEngine,
+          enabledElement
+        );
+      }
+    }
+  }
+
+  private _calculateCachedStats = (
     annotation,
     viewport,
     renderingEngine,
     enabledElement
   ) => {
-    const data = annotation.data;
-    const { cachedStats, polyline: points } = data;
+    const { data } = annotation;
+    const { cachedStats } = data;
+    const { polyline: points } = data.contour;
 
     const targetIds = Object.keys(cachedStats);
 
@@ -890,8 +851,13 @@ class PlanarFreehandROITool extends AnnotationTool {
     return cachedStats;
   };
 
-  _renderStats = (annotation, viewport, enabledElement, svgDrawingHelper) => {
-    const data = annotation.data;
+  private _renderStats = (
+    annotation,
+    viewport,
+    enabledElement,
+    svgDrawingHelper
+  ) => {
+    const { data } = <PlanarFreehandROIAnnotation>annotation;
     const targetId = this.getTargetId(viewport);
 
     const styleSpecifier: AnnotationStyle.StyleSpecifier = {
@@ -910,7 +876,7 @@ class PlanarFreehandROITool extends AnnotationTool {
       return;
     }
 
-    const canvasCoordinates = data.polyline.map((p) =>
+    const canvasCoordinates = data.contour.polyline.map((p) =>
       viewport.worldToCanvas(p)
     );
     if (!data.handles.textBox.hasMoved) {

package/src/tools/annotation/ProbeTool.ts

@@ -441,7 +441,7 @@ class ProbeTool extends AnnotationTool {
 
       styleSpecifier.annotationUID = annotationUID;
 
-      const color = this.getStyle('color', styleSpecifier, annotation);
+      const { color } = this.getAnnotationStyle({ annotation, styleSpecifier });
 
       if (
         !data.cachedStats[targetId] ||

package/src/tools/annotation/RectangleROITool.ts

@@ -652,9 +652,10 @@ class RectangleROITool 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 { viewPlaneNormal, viewUp } = viewport.getCamera();
 

package/src/tools/annotation/SplineContourSegmentationTool.ts

@@ -0,0 +1,28 @@
+import { utilities } from '@cornerstonejs/core';
+import { PublicToolProps } from '../../types';
+import SplineROITool from './SplineROITool';
+
+class SplineContourSegmentationTool extends SplineROITool {
+  static toolName;
+
+  constructor(toolProps: PublicToolProps) {
+    const initialProps = utilities.deepMerge(
+      {
+        configuration: {
+          calculateStats: false,
+        },
+      },
+      toolProps
+    );
+
+    super(initialProps);
+  }
+
+  protected isContourSegmentationTool(): boolean {
+    // Re-enable contour segmentation behavior disabled by SplineROITool
+    return true;
+  }
+}
+
+SplineContourSegmentationTool.toolName = 'SplineContourSegmentationTool';
+export default SplineContourSegmentationTool;