@cornerstonejs/tools 1.63.1 → 1.63.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.63.1",
+  "version": "1.63.3",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.63.1",
+    "@cornerstonejs/core": "^1.63.3",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
@@ -59,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "e4fcacba07b254d69218c70e5e549a696115f008"
+  "gitHead": "027b911678b62776ca4407fe900a47e1f5045e14"
 }

package/src/tools/annotation/KeyImageTool.ts

@@ -89,37 +89,9 @@ class KeyImageTool extends AnnotationTool {
       viewUp
     );
 
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-
-    const annotation = {
-      annotationUID: null as string,
-      highlighted: true,
-      invalidated: true,
-      metadata: {
-        toolName: this.getToolName(),
-        viewPlaneNormal: <Types.Point3>[...viewPlaneNormal],
-        viewUp: <Types.Point3>[...viewUp],
-        FrameOfReferenceUID,
-        referencedImageId,
-      },
-      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: '',
-      },
-    };
+    const annotation = KeyImageTool.createAnnotation({
+      metadata: { ...viewport.getViewReference(), referencedImageId },
+    });
 
     addAnnotation(annotation, element);
 

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

@@ -1,4 +1,4 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import {
   resetElementCursor,
   hideElementCursor,
@@ -190,9 +190,9 @@ function mouseUpDrawCallback(evt: EventTypes.InteractionEventType): void {
       this.configuration.closeContourProximity
     )
   ) {
-    this.completeDrawOpenContour(element, contourHoleProcessingEnabled);
+    this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
   } else {
-    this.completeDrawClosedContour(element, contourHoleProcessingEnabled);
+    this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
   }
 }
 
@@ -201,10 +201,19 @@ function mouseUpDrawCallback(evt: EventTypes.InteractionEventType): void {
  */
 function completeDrawClosedContour(
   element: HTMLDivElement,
-  contourHoleProcessingEnabled: boolean
+  options: {
+    contourHoleProcessingEnabled: boolean;
+    minPointsToSave: number;
+  }
 ): boolean {
   this.removeCrossedLinesOnCompleteDraw();
+
   const { canvasPoints } = this.drawData;
+  const { contourHoleProcessingEnabled, minPointsToSave } = options ?? {};
+
+  if (minPointsToSave && canvasPoints.length < minPointsToSave) {
+    return false;
+  }
 
   // check and halt if necessary the drawing process, last chance to complete drawing and fire events.
   if (this.haltDrawing(element, canvasPoints)) {
@@ -280,7 +289,13 @@ function removeCrossedLinesOnCompleteDraw(): void {
   if (lineSegment) {
     const indexToRemoveUpTo = lineSegment[1];
 
-    this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+    // It is better to remove the last point when the user just moved the mouse
+    // cursor back than deleting the entire contour
+    if (indexToRemoveUpTo === 1) {
+      this.drawData.canvasPoints = canvasPoints.splice(1);
+    } else {
+      this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+    }
   }
 }
 
@@ -289,9 +304,12 @@ function removeCrossedLinesOnCompleteDraw(): void {
  */
 function completeDrawOpenContour(
   element: HTMLDivElement,
-  contourHoleProcessingEnabled: boolean
+  options: {
+    contourHoleProcessingEnabled: boolean;
+  }
 ): boolean {
   const { canvasPoints } = this.drawData;
+  const { contourHoleProcessingEnabled } = options ?? {};
 
   // check and halt if necessary the drawing process, last chance to complete drawing and fire events.
   if (this.haltDrawing(element, canvasPoints)) {
@@ -392,7 +410,7 @@ function applyCreateOnCross(
 ): void {
   const eventDetail = evt.detail;
   const { element } = eventDetail;
-  const { canvasPoints } = this.drawData;
+  const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
   const { annotation, viewportIdsToRender } = this.commonData;
 
   // Add points between the end point and crossing point
@@ -405,12 +423,24 @@ function applyCreateOnCross(
   // Remove last point which will be a duplicate now.
   canvasPoints.pop();
 
-  // Remove points up to just before the crossing index
-  for (let i = 0; i < crossingIndex; i++) {
-    canvasPoints.shift();
+  const remainingPoints = canvasPoints.slice(crossingIndex);
+  const newArea = polyline.getArea(remainingPoints);
+
+  // User just moved the mouse back and the last points must be removed
+  // otherwise the entire contour drawn would be lost.
+  if (utilities.isEqual(newArea, 0)) {
+    canvasPoints.splice(crossingIndex + 1);
+    return;
   }
 
-  if (this.completeDrawClosedContour(element)) {
+  canvasPoints.splice(0, crossingIndex);
+
+  // There is no contour with less than 3 points.
+  // It's possible to have a contour with very few points after removing
+  // crossed lines which is not enough to save as a contour.
+  const options = { contourHoleProcessingEnabled, minPointsToSave: 3 };
+
+  if (this.completeDrawClosedContour(element, options)) {
     // pos complete operation
     this.activateClosedContourEdit(evt, annotation, viewportIdsToRender);
   }
@@ -433,9 +463,9 @@ function cancelDrawing(element: HTMLElement) {
       this.configuration.closeContourProximity
     )
   ) {
-    this.completeDrawOpenContour(element, contourHoleProcessingEnabled);
+    this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
   } else {
-    this.completeDrawClosedContour(element, contourHoleProcessingEnabled);
+    this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
   }
 }
 

package/src/tools/base/AnnotationTool.ts

@@ -3,6 +3,7 @@ import {
   cache,
   getEnabledElement,
   metaData,
+  utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
@@ -19,11 +20,12 @@ import {
   InteractionTypes,
   ToolProps,
   PublicToolProps,
-  IToolBinding,
 } 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.

package/src/utilities/math/polyline/addCanvasPointsToArray.ts

@@ -16,11 +16,16 @@ const addCanvasPointsToArray = (
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
+  if (!canvasPoints.length) {
+    canvasPoints.push(newCanvasPoint);
+    console.log('>>>>> !canvasPoints. :: RETURN');
+    return 1;
+  }
+
   const lastWorldPos = viewport.canvasToWorld(
     canvasPoints[canvasPoints.length - 1]
   );
   const newWorldPos = viewport.canvasToWorld(newCanvasPoint);
-
   const worldPosDiff = vec3.create();
 
   vec3.subtract(worldPosDiff, newWorldPos, lastWorldPos);

package/src/utilities/math/polyline/getSignedArea.ts

@@ -13,6 +13,10 @@ import type { Types } from '@cornerstonejs/core';
  * @returns Area of the polyline (with signal)
  */
 export default function getSignedArea(polyline: Types.Point2[]): number {
+  if (polyline.length < 3) {
+    return 0;
+  }
+
   // Reference point can be any point on the same plane
   const refPoint = polyline[0];
   let area = 0;