@cornerstonejs/tools 2.0.0-beta.5 → 2.0.0-beta.7

package/src/tools/base/AnnotationDisplayTool.ts

@@ -1,9 +1,9 @@
 import {
   utilities,
   getEnabledElement,
-  VolumeViewport,
   StackViewport,
   cache,
+  VideoViewport,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
@@ -123,7 +123,7 @@ abstract class AnnotationDisplayTool extends BaseTool {
   };
 
   protected getReferencedImageId(
-    viewport: Types.IStackViewport | Types.IVolumeViewport,
+    viewport: Types.IViewport,
     worldPos: Types.Point3,
     viewPlaneNormal: Types.Point3,
     viewUp: Types.Point3
@@ -134,8 +134,10 @@ abstract class AnnotationDisplayTool extends BaseTool {
 
     if (viewport instanceof StackViewport) {
       referencedImageId = targetId.split('imageId:')[1];
+    } else if (viewport instanceof VideoViewport) {
+      referencedImageId = targetId.split('videoId:')[1];
     } else {
-      const volumeId = targetId.split('volumeId:')[1];
+      const volumeId = utilities.getVolumeId(targetId);
       const imageVolume = cache.getVolume(volumeId);
 
       referencedImageId = utilities.getClosestImageId(

package/src/tools/base/AnnotationTool.ts

@@ -1,9 +1,9 @@
 import {
   BaseVolumeViewport,
-  StackViewport,
   cache,
   getEnabledElement,
   metaData,
+  utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
@@ -21,9 +21,11 @@ import {
   ToolProps,
   PublicToolProps,
 } from '../../types';
+import { addAnnotation } from '../../stateManagement/annotation/annotationState';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 
-/**-q
+/**
  * Abstract class for tools which create and display annotations on the
  * cornerstone3D canvas. In addition, it provides a base class for segmentation
  * tools that require drawing an annotation before running the segmentation strategy
@@ -34,6 +36,70 @@ import { StyleSpecifier } from '../../types/AnnotationStyle';
  * abstract methods.
  */
 abstract class AnnotationTool extends AnnotationDisplayTool {
+  /**
+   * Creates a base annotation object, adding in any annotation base data provided
+   */
+  public static createAnnotation(...annotationBaseData): Annotation {
+    let annotation: Annotation = {
+      annotationUID: null as string,
+      highlighted: true,
+      invalidated: true,
+      metadata: {
+        toolName: this.toolName,
+      },
+      data: {
+        text: '',
+        handles: {
+          points: new Array<Types.Point3>(),
+          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],
+            },
+          },
+        },
+        label: '',
+      },
+    } as unknown as Annotation;
+    for (const baseData of annotationBaseData) {
+      annotation = csUtils.deepMerge(annotation, baseData);
+    }
+    return annotation;
+  }
+
+  /**
+   * Creates a new annotation for the given viewport.  This just adds the
+   * viewport reference data to the metadata, and otherwise returns the
+   * static class createAnnotation data.
+   */
+  public static createAnnotationForViewport(viewport, ...annotationBaseData) {
+    return this.createAnnotation(
+      { metadata: viewport.getViewReference() },
+      ...annotationBaseData
+    );
+  }
+
+  /**
+   * Creates and adds an annotation of the given type, firing the annotation
+   * modified event on the new annotation.
+   * This implicitly uses the static class when you call it on the correct
+   * base class.  For example, you can call the KeyImageTool.createAnnotation
+   * method on KeyImageTool.toolName by calling KeyImageTool.createAndAddAnnotation
+   *
+   */
+  public static createAndAddAnnotation(viewport, ...annotationBaseData) {
+    const annotation = this.createAnnotationForViewport(
+      viewport,
+      ...annotationBaseData
+    );
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationModified(annotation, viewport.element);
+  }
+
   static toolName;
   // ===================================================================
   // Abstract Methods - Must be implemented.
@@ -200,6 +266,7 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     const { viewport } = enabledElement;
 
     const { data } = annotation;
+    const { isCanvasAnnotation } = data;
     const { points, textBox } = data.handles;
 
     if (textBox) {
@@ -219,17 +286,22 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
           canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
         ) {
           data.handles.activeHandleIndex = null;
-          return textBox;
+          return textBox as ToolHandle;
         }
       }
     }
 
-    for (let i = 0; i < points.length; i++) {
+    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;
@@ -302,16 +374,48 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     imageId?: string
   ): boolean {
     if (viewport instanceof BaseVolumeViewport) {
-      const volumeId = targetId.split('volumeId:')[1];
+      const volumeId = csUtils.getVolumeId(targetId);
       const volume = cache.getVolume(volumeId);
-      return volume.scaling?.PT !== undefined;
-    } else if (viewport instanceof StackViewport) {
-      const scalingModule: Types.ScalingParameters | undefined =
-        imageId && metaData.get('scalingModule', imageId);
-      return typeof scalingModule?.suvbw === 'number';
-    } else {
-      throw new Error('Viewport is not a valid type');
+      return volume?.scaling?.PT !== undefined;
     }
+    const scalingModule: Types.ScalingParameters | undefined =
+      imageId && metaData.get('scalingModule', imageId);
+    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,
+    };
   }
 
   /**

package/src/tools/base/BaseTool.ts

@@ -1,10 +1,7 @@
-import {
-  StackViewport,
-  utilities,
-  BaseVolumeViewport,
-} from '@cornerstonejs/core';
+import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
 import { Types } from '@cornerstonejs/core';
-import { ToolModes } from '../../enums';
+import ToolModes from '../../enums/ToolModes';
+import StrategyCallbacks from '../../enums/StrategyCallbacks';
 import { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
 
 export interface IBaseTool {
@@ -72,7 +69,8 @@ abstract class BaseTool implements IBaseTool {
   }
 
   /**
-   * It applies the active strategy to the enabled element.
+   * Applies the active strategy function to the enabled element with the specified
+   * operation data.
    * @param enabledElement - The element that is being operated on.
    * @param operationData - The data that needs to be passed to the strategy.
    * @returns The result of the strategy.
@@ -82,7 +80,42 @@ abstract class BaseTool implements IBaseTool {
     operationData: unknown
   ): any {
     const { strategies, activeStrategy } = this.configuration;
-    return strategies[activeStrategy].call(this, enabledElement, operationData);
+    return strategies[activeStrategy]?.call(
+      this,
+      enabledElement,
+      operationData
+    );
+  }
+
+  /**
+   * Applies the active strategy, with a given event type being applied.
+   * The event type function is found by indexing it on the active strategy
+   * function.
+   *
+   * @param enabledElement - The element that is being operated on.
+   * @param operationData - The data that needs to be passed to the strategy.
+   * @param callbackType - the type of the callback
+   *
+   * @returns The result of the strategy.
+   */
+  public applyActiveStrategyCallback(
+    enabledElement: Types.IEnabledElement,
+    operationData: unknown,
+    callbackType: StrategyCallbacks | string
+  ): any {
+    const { strategies, activeStrategy } = this.configuration;
+
+    if (!strategies[activeStrategy]) {
+      throw new Error(
+        `applyActiveStrategyCallback: active strategy ${activeStrategy} not found, check tool configuration or spellings`
+      );
+    }
+
+    return strategies[activeStrategy][callbackType]?.call(
+      this,
+      enabledElement,
+      operationData
+    );
   }
 
   /**
@@ -140,7 +173,10 @@ abstract class BaseTool implements IBaseTool {
 
   /**
    * Get the image that is displayed for the targetId in the cachedStats
-   * which can be either imageId:<imageId> or volumeId:<volumeId>
+   * which can be
+   * * imageId:<imageId>
+   * * volumeId:<volumeId>
+   * * videoId:<basePathForVideo>/frames/<frameSpecifier>
    *
    * @param targetId - annotation targetId stored in the cached stats
    * @param renderingEngine - The rendering engine
@@ -172,7 +208,7 @@ abstract class BaseTool implements IBaseTool {
 
       return viewports[0].getImageData();
     } else if (targetId.startsWith('volumeId:')) {
-      const volumeId = targetId.split('volumeId:')[1];
+      const volumeId = utilities.getVolumeId(targetId);
       const viewports = utilities.getViewportsWithVolumeId(
         volumeId,
         renderingEngine.id
@@ -182,6 +218,19 @@ abstract class BaseTool implements IBaseTool {
         return;
       }
 
+      return viewports[0].getImageData();
+    } else if (targetId.startsWith('videoId:')) {
+      // Video id can be multi-valued for the frame information
+      const imageURI = utilities.imageIdToURI(targetId);
+      const viewports = utilities.getViewportsWithImageURI(
+        imageURI,
+        renderingEngine.id
+      );
+
+      if (!viewports || !viewports.length) {
+        return;
+      }
+
       return viewports[0].getImageData();
     } else {
       throw new Error(
@@ -201,15 +250,14 @@ abstract class BaseTool implements IBaseTool {
    * @returns targetId
    */
   protected getTargetId(viewport: Types.IViewport): string | undefined {
-    if (viewport instanceof StackViewport) {
-      return `imageId:${viewport.getCurrentImageId()}`;
-    } else if (viewport instanceof BaseVolumeViewport) {
+    const targetId = viewport.getReferenceId?.();
+    if (targetId) {
+      return targetId;
+    }
+    if (viewport instanceof BaseVolumeViewport) {
       return `volumeId:${this.getTargetVolumeId(viewport)}`;
-    } else {
-      throw new Error(
-        'getTargetId: viewport must be a StackViewport or VolumeViewport'
-      );
     }
+    throw new Error('getTargetId: viewport must have a getTargetId method');
   }
 }
 

package/src/tools/base/ContourBaseTool.ts

@@ -0,0 +1,291 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import {
+  addAnnotation,
+  getAnnotations,
+  getChildAnnotations,
+} from '../../stateManagement/annotation/annotationState';
+import type {
+  Annotation,
+  ContourAnnotation,
+  EventTypes,
+  PublicToolProps,
+  ToolProps,
+  SVGDrawingHelper,
+  AnnotationRenderContext,
+} from '../../types';
+import { drawPath as drawPathSvg } from '../../drawingSvg';
+import { StyleSpecifier } from '../../types/AnnotationStyle';
+import AnnotationTool from './AnnotationTool';
+import { updateContourPolyline } from '../../utilities/contours/';
+import { getContourHolesDataCanvas } from '../../utilities/contours';
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
+
+/**
+ * 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, position: cameraPosition } = camera;
+
+    const referencedImageId = this.getReferencedImageId(
+      viewport,
+      worldPos,
+      viewPlaneNormal,
+      viewUp
+    );
+
+    const viewReference = viewport.getViewReference({ points: [worldPos] });
+
+    return <ContourAnnotation>{
+      highlighted: true,
+      invalidated: true,
+      metadata: {
+        toolName: this.getToolName(),
+        ...viewReference,
+        referencedImageId,
+        viewUp,
+        cameraPosition,
+      },
+      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,
+        },
+      },
+      interpolationUID: '',
+      autoGenerated: 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
+  }
+
+  /**
+   * Move an annotation and all its child annotations in a recursive way.
+   *
+   * That is useful when clicking on a spline contour to completely translate
+   * it to a different place. In that case all holes (child annotations) must
+   * also be translated too.
+   *
+   * @param annotation - Annotation
+   * @param worldPosDelta - Delta in world space
+   */
+  protected moveAnnotation(
+    annotation: Annotation,
+    worldPosDelta: Types.Point3
+  ): void {
+    const { points } = annotation.data.handles;
+
+    for (let i = 0, numPoints = points.length; i < numPoints; i++) {
+      const point = points[i];
+
+      point[0] += worldPosDelta[0];
+      point[1] += worldPosDelta[1];
+      point[2] += worldPosDelta[2];
+    }
+
+    annotation.invalidated = true;
+
+    getChildAnnotations(annotation).forEach((childAnnotation) =>
+      this.moveAnnotation(childAnnotation, worldPosDelta)
+    );
+  }
+
+  protected updateContourPolyline(
+    annotation: ContourAnnotation,
+    polylineData: {
+      points: Types.Point2[];
+      closed?: boolean;
+      targetWindingDirection?: ContourWindingDirection;
+    },
+    transforms: {
+      canvasToWorld: (point: Types.Point2) => Types.Point3;
+      worldToCanvas: (point: Types.Point3) => Types.Point2;
+    }
+  ) {
+    const decimateConfig = this.configuration?.decimate || {};
+
+    updateContourPolyline(annotation, polylineData, transforms, {
+      decimate: {
+        enabled: !!decimateConfig.enabled,
+        epsilon: decimateConfig.epsilon,
+      },
+    });
+  }
+
+  /**
+   * 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[] {
+    // Attention: `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: AnnotationRenderContext
+  ): boolean {
+    const { enabledElement, annotationStyle, svgDrawingHelper } = renderContext;
+    const annotation = renderContext.annotation as ContourAnnotation;
+
+    // Do not render the contour because it must be rendered by the parent annotation
+    if (annotation.parentAnnotationUID) {
+      return;
+    }
+
+    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;
+
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [polylineCanvasPoints, ...childContours];
+
+    drawPathSvg(
+      svgDrawingHelper,
+      annotationUID,
+      'contourPolyline',
+      allContours,
+      {
+        color,
+        lineDash,
+        lineWidth: Math.max(0.1, lineWidth),
+        fillColor: fillColor,
+        fillOpacity,
+      }
+    );
+
+    return true;
+  }
+}
+
+export { ContourBaseTool as default, ContourBaseTool };