@cornerstonejs/tools 1.43.6 → 1.44.0

package/src/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.ts

@@ -68,7 +68,9 @@ export function findOpenUShapedContourVectorToPeakOnRender(
   annotation: PlanarFreehandROIAnnotation
 ): Types.Point3[] {
   const { viewport } = enabledElement;
-  const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const canvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
 
   return findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
 }

package/src/tools/annotation/planarFreehandROITool/openContourEditLoop.ts

@@ -6,7 +6,8 @@ import {
   resetElementCursor,
   hideElementCursor,
 } from '../../../cursors/elementCursor';
-import type { EventTypes, Annotation } from '../../../types';
+import type { EventTypes } from '../../../types';
+import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import { vec3, vec2 } from 'gl-matrix';
 import { polyline } from '../../../utilities/math';
 import {
@@ -23,7 +24,7 @@ const { addCanvasPointsToArray, getSubPixelSpacingAndXYDirections } = polyline;
  */
 function activateOpenContourEdit(
   evt: EventTypes.InteractionEventType,
-  annotation: Annotation,
+  annotation: PlanarFreehandROIAnnotation,
   viewportIdsToRender: string[]
 ): void {
   this.isEditingOpen = true;
@@ -34,7 +35,9 @@ function activateOpenContourEdit(
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
-  const prevCanvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const prevCanvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
 
   const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(
     viewport,
@@ -213,8 +216,8 @@ function openContourEditOverwriteEnd(
     viewport.canvasToWorld(canvasPoint)
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = true;
+  annotation.data.contour.polyline = worldPoints;
+  annotation.data.contour.closed = false;
   // Note: Contours generate from fusedCanvasPoints will be in the direction
   // with the last point being the current mouse position
   annotation.data.handles.points = [
@@ -495,8 +498,8 @@ function finishEditOpenOnSecondCrossing(
     viewport.canvasToWorld(canvasPoint)
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = true;
+  annotation.data.contour.polyline = worldPoints;
+  annotation.data.contour.closed = false;
   annotation.data.handles.points = [
     worldPoints[0],
     worldPoints[worldPoints.length - 1],
@@ -550,8 +553,8 @@ function completeOpenContourEdit(element: HTMLDivElement) {
     const worldPoints = updatedPoints.map((canvasPoint) =>
       viewport.canvasToWorld(canvasPoint)
     );
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = true;
+    annotation.data.contour.polyline = worldPoints;
+    annotation.data.contour.closed = false;
     annotation.data.handles.points = [
       worldPoints[0],
       worldPoints[worldPoints.length - 1],

package/src/tools/annotation/planarFreehandROITool/openContourEndEditLoop.ts

@@ -8,6 +8,7 @@ import type {
   ToolHandle,
   TextBoxHandle,
 } from '../../../types';
+import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import { polyline } from '../../../utilities/math';
 
 const { getSubPixelSpacingAndXYDirections } = polyline;
@@ -18,7 +19,7 @@ const { getSubPixelSpacingAndXYDirections } = polyline;
  */
 function activateOpenContourEndEdit(
   evt: EventTypes.InteractionEventType,
-  annotation: Annotation,
+  annotation: PlanarFreehandROIAnnotation,
   viewportIdsToRender: string[],
   handle: ToolHandle | null
 ): void {
@@ -34,7 +35,9 @@ function activateOpenContourEndEdit(
     this.configuration.subPixelResolution
   );
 
-  const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const canvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
   const handleIndexGrabbed = annotation.data.handles.activeHandleIndex;
 
   // If 0, invert point direction, if 1, keep point direction the same.

package/src/tools/annotation/planarFreehandROITool/renderMethods.ts

@@ -28,17 +28,21 @@ function _getRenderingOptions(
     annotationUID: annotation.annotationUID,
   };
 
-  const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-  const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-  const color = this.getStyle('color', styleSpecifier, annotation);
+  const { lineWidth, lineDash, color, fillColor, fillOpacity } =
+    this.getAnnotationStyle({
+      annotation,
+      styleSpecifier,
+    });
 
-  const isOpenContour = annotation.data.isOpenContour;
+  const { closed: isClosedContour } = annotation.data.contour;
 
   const options = {
-    color: color === undefined ? undefined : <string>color,
-    width: lineWidth === undefined ? undefined : <number>lineWidth,
-    lineDash: lineDash === undefined ? undefined : <number[]>lineDash,
-    connectLastToFirst: !isOpenContour,
+    color,
+    width: lineWidth,
+    lineDash,
+    fillColor,
+    fillOpacity,
+    connectLastToFirst: isClosedContour,
   };
 
   return options;
@@ -57,7 +61,9 @@ function renderContour(
     return;
   }
   // Check if the contour is an open contour
-  if (annotation.data.isOpenContour) {
+  if (annotation.data.contour.closed) {
+    this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
+  } else {
     // If its an open contour, check i its a U-shaped contour
     if (annotation.data.isOpenUShapeContour) {
       calculateUShapeContourVectorToPeakIfNotPresent(
@@ -74,8 +80,6 @@ function renderContour(
       // If not a U-shaped contour, render standard open contour.
       this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
     }
-  } else {
-    this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
   }
 }
 
@@ -110,7 +114,7 @@ function renderClosedContour(
   // element on the tool? That feels very weird also as we'd need to manage
   // it/clean them up. Its a pre-optimisation for now and we can tackle it if it
   // becomes a problem.
-  const canvasPoints = annotation.data.polyline.map((worldPos) =>
+  const canvasPoints = annotation.data.contour.polyline.map((worldPos) =>
     viewport.worldToCanvas(worldPos)
   );
 
@@ -136,7 +140,7 @@ function renderOpenContour(
   const { viewport } = enabledElement;
   const options = this._getRenderingOptions(enabledElement, annotation);
 
-  const canvasPoints = annotation.data.polyline.map((worldPos) =>
+  const canvasPoints = annotation.data.contour.polyline.map((worldPos) =>
     viewport.worldToCanvas(worldPos)
   );
 
@@ -212,7 +216,8 @@ function renderOpenUShapedContour(
   annotation: PlanarFreehandROIAnnotation
 ): void {
   const { viewport } = enabledElement;
-  const { polyline, openUShapeContourVectorToPeak } = annotation.data;
+  const { openUShapeContourVectorToPeak } = annotation.data;
+  const { polyline } = annotation.data.contour;
 
   this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
 

package/src/tools/base/AnnotationTool.ts

@@ -310,6 +310,41 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     return typeof scalingModule?.suvbw === 'number';
   }
 
+  /**
+   * Get the style that will be applied to all annotations such as length, cobb
+   * angle, arrow annotate, etc. when rendered on a canvas or svg layer
+   */
+  protected getAnnotationStyle(context: {
+    annotation: Annotation;
+    styleSpecifier: StyleSpecifier;
+  }) {
+    const { annotation, styleSpecifier } = context;
+    const getStyle = (property) =>
+      this.getStyle(property, styleSpecifier, annotation);
+    const { annotationUID } = annotation;
+    const visibility = isAnnotationVisible(annotationUID);
+    const locked = isAnnotationLocked(annotation);
+
+    const lineWidth = getStyle('lineWidth') as number;
+    const lineDash = getStyle('lineDash') as string;
+    const color = getStyle('color') as string;
+    const shadow = getStyle('shadow') as boolean;
+    const textboxStyle = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+
+    return {
+      visibility,
+      locked,
+      color,
+      lineWidth,
+      lineDash,
+      lineOpacity: 1,
+      fillColor: color,
+      fillOpacity: 0,
+      shadow,
+      textbox: textboxStyle,
+    };
+  }
+
   /**
    * Returns true if the `canvasCoords` are near a handle or selectable part of the tool
    *

package/src/tools/base/ContourBaseTool.ts

@@ -0,0 +1,226 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import {
+  addAnnotation,
+  getAnnotations,
+} from '../../stateManagement/annotation/annotationState';
+import {
+  Annotation,
+  ContourAnnotation,
+  EventTypes,
+  PublicToolProps,
+  ToolProps,
+  SVGDrawingHelper,
+} from '../../types';
+import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
+import { StyleSpecifier } from '../../types/AnnotationStyle';
+import AnnotationTool from './AnnotationTool';
+
+/**
+ * A contour base class responsible for rendering contour instances such as
+ * spline, freehand and livewire.
+ */
+abstract class ContourBaseTool extends AnnotationTool {
+  constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
+    super(toolProps, defaultToolProps);
+  }
+
+  /**
+   * it is used to draw the annotation in each request animation frame. It
+   * calculates the updated cached statistics if data is invalidated and cache it.
+   * @param enabledElement - The Cornerstone's enabledElement.
+   * @param svgDrawingHelper - The svgDrawingHelper providing the context for drawing.
+   */
+  public renderAnnotation(
+    enabledElement: Types.IEnabledElement,
+    svgDrawingHelper: SVGDrawingHelper
+  ): boolean {
+    let renderStatus = false;
+    const { viewport } = enabledElement;
+    const { element } = viewport;
+
+    // If rendering engine has been destroyed while rendering
+    if (!viewport.getRenderingEngine()) {
+      console.warn('Rendering Engine has been destroyed');
+      return renderStatus;
+    }
+
+    let annotations = getAnnotations(this.getToolName(), element);
+
+    if (!annotations?.length) {
+      return renderStatus;
+    }
+
+    annotations = this.filterInteractableAnnotationsForElement(
+      element,
+      annotations
+    );
+
+    if (!annotations?.length) {
+      return renderStatus;
+    }
+
+    const targetId = this.getTargetId(viewport);
+    const styleSpecifier: StyleSpecifier = {
+      toolGroupId: this.toolGroupId,
+      toolName: this.getToolName(),
+      viewportId: enabledElement.viewport.id,
+    };
+
+    for (let i = 0; i < annotations.length; i++) {
+      const annotation = annotations[i] as Annotation;
+
+      styleSpecifier.annotationUID = annotation.annotationUID;
+
+      const annotationStyle = this.getAnnotationStyle({
+        annotation,
+        styleSpecifier,
+      });
+
+      if (!annotationStyle.visibility) {
+        continue;
+      }
+
+      const annotationRendered = this.renderAnnotationInstance({
+        enabledElement,
+        targetId,
+        annotation,
+        annotationStyle,
+        svgDrawingHelper,
+      });
+
+      renderStatus ||= annotationRendered;
+      annotation.invalidated = false;
+    }
+
+    return renderStatus;
+  }
+
+  protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation {
+    const eventDetail = evt.detail;
+    const { currentPoints, element } = eventDetail;
+    const { world: worldPos } = currentPoints;
+
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+
+    const camera = viewport.getCamera();
+    const { viewPlaneNormal, viewUp } = camera;
+
+    const referencedImageId = this.getReferencedImageId(
+      viewport,
+      worldPos,
+      viewPlaneNormal,
+      viewUp
+    );
+
+    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+
+    return <ContourAnnotation>{
+      highlighted: true,
+      invalidated: true,
+      metadata: {
+        toolName: this.getToolName(),
+        viewPlaneNormal: <Types.Point3>[...viewPlaneNormal],
+        viewUp: <Types.Point3>[...viewUp],
+        FrameOfReferenceUID,
+        referencedImageId,
+      },
+      data: {
+        handles: {
+          points: [],
+          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],
+            },
+          },
+        },
+        contour: {
+          polyline: [],
+          closed: false,
+        },
+      },
+    };
+  }
+
+  /**
+   * Add the annotation to the annotation manager.
+   * @param annotation - Contour annotation that is being added
+   * @param element - HTMLDivElement
+   */
+  protected addAnnotation(
+    annotation: Annotation,
+    element: HTMLDivElement
+  ): string {
+    // Just to give a chance for child classes to override it
+    return addAnnotation(annotation, element);
+  }
+
+  /**
+   * Cancel an annotation when drawing.
+   * @param annotation - Contour annotation that is being added
+   * @param element - HTMLDivElement
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  protected cancelAnnotation(annotation: Annotation): void {
+    // noop method just to give a chance for child classes to override it
+  }
+
+  /**
+   * Get polyline points in world space.
+   * Just to give a chance for child classes to override it.
+   * @param annotation - Contour annotation
+   * @returns Polyline points in world space
+   */
+  protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[] {
+    // Attenttion: `contour.polyline` is the new way to store a polyline but it
+    // may be undefined because it was `data.polyline` before (fallback)
+    return annotation.data.contour?.polyline ?? annotation.data.polyline;
+  }
+
+  /**
+   * Render a contour segmentation instance
+   */
+  protected renderAnnotationInstance(renderContext: {
+    enabledElement: Types.IEnabledElement;
+    targetId: string;
+    annotation: Annotation;
+    annotationStyle: Record<string, any>;
+    svgDrawingHelper: SVGDrawingHelper;
+  }): boolean {
+    const { enabledElement, annotationStyle, svgDrawingHelper } = renderContext;
+    const annotation = renderContext.annotation as ContourAnnotation;
+    const { annotationUID } = annotation;
+    const { viewport } = enabledElement;
+    const { worldToCanvas } = viewport;
+    const polylineCanvasPoints = this.getPolylinePoints(annotation).map(
+      (point) => worldToCanvas(point)
+    );
+    const { lineWidth, lineDash, color, fillColor, fillOpacity } =
+      annotationStyle;
+
+    drawPolylineSvg(
+      svgDrawingHelper,
+      annotationUID,
+      'contourPolyline',
+      polylineCanvasPoints,
+      {
+        color,
+        lineDash,
+        lineWidth: Math.max(0.1, lineWidth),
+        fillColor: fillColor,
+        fillOpacity,
+      }
+    );
+
+    return true;
+  }
+}
+
+export { ContourBaseTool as default, ContourBaseTool };