@cornerstonejs/tools 1.72.5 → 1.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.72.5",
+  "version": "1.73.0",
   "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.72.5",
+    "@cornerstonejs/core": "^1.73.0",
     "@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": "475e831d61c00535b40c108a8b940e5bdf3ae0f6"
+  "gitHead": "7d9375494668c1b3857c560643e490470d35523d"
 }

package/src/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.ts

@@ -19,6 +19,11 @@ import {
 import { checkAndDefineIsLockedProperty } from './annotationLocking';
 import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 
+import {
+  checkAndDefineTextBoxProperty,
+  checkAndDefineCachedStatsProperty,
+} from './utilities/defineProperties';
+
 /**
  * This is the default annotation manager. It stores annotations by default
  * based on the FrameOfReferenceUID. However, it is possible to override the
@@ -236,6 +241,8 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     toolSpecificAnnotations.push(annotation);
     checkAndDefineIsLockedProperty(annotation);
     checkAndDefineIsVisibleProperty(annotation);
+    checkAndDefineTextBoxProperty(annotation);
+    checkAndDefineCachedStatsProperty(annotation);
   };
 
   /**

package/src/stateManagement/annotation/utilities/defineProperties.ts

@@ -0,0 +1,26 @@
+import { Annotation } from '../../../types';
+
+const checkAndDefineTextBoxProperty = (annotation: Annotation) => {
+  if (!annotation.data) {
+    annotation.data = {};
+  }
+  if (!annotation.data.handles) {
+    annotation.data.handles = {};
+  }
+  if (!annotation.data.handles.textBox) {
+    annotation.data.handles.textBox = {};
+  }
+  return annotation;
+};
+
+const checkAndDefineCachedStatsProperty = (annotation: Annotation) => {
+  if (!annotation.data) {
+    annotation.data = {};
+  }
+  if (!annotation.data.cachedStats) {
+    annotation.data.cachedStats = {};
+  }
+  return annotation;
+};
+
+export { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty };

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -170,6 +170,12 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     annotation: PlanarFreehandROIAnnotation
   ) => void;
 
+  private renderPointContourWithMarker: (
+    enabledElement: Types.IEnabledElement,
+    svgDrawingHelper: SVGDrawingHelper,
+    annotation: PlanarFreehandROIAnnotation
+  ) => void;
+
   constructor(
     toolProps: PublicToolProps = {},
     defaultToolProps: ToolProps = {
@@ -242,6 +248,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
            */
           epsilon: 0.1,
         },
+        displayOnePointAsCrosshairs: false,
         calculateStats: true,
         getTextLines: defaultGetTextLines,
         statsCalculator: BasicStatsCalculator,
@@ -578,7 +585,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     if (!(isDrawing || isEditingOpen || isEditingClosed)) {
       // No annotations are currently being modified, so we can just use the
       // render contour method to render all of them
-      this.renderContour(enabledElement, svgDrawingHelper, annotation);
+      if (
+        this.configuration.displayOnePointAsCrosshairs &&
+        annotation.data.contour.polyline.length === 1
+      ) {
+        this.renderPointContourWithMarker(
+          enabledElement,
+          svgDrawingHelper,
+          annotation
+        );
+      } else {
+        this.renderContour(enabledElement, svgDrawingHelper, annotation);
+      }
     } else {
       // The active annotation will need special rendering treatment. Render all
       // other annotations not being interacted with using the standard renderContour
@@ -610,7 +628,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
           );
         }
       } else {
-        this.renderContour(enabledElement, svgDrawingHelper, annotation);
+        if (
+          this.configuration.displayOnePointAsCrosshairs &&
+          annotation.data.contour.polyline.length === 1
+        ) {
+          this.renderPointContourWithMarker(
+            enabledElement,
+            svgDrawingHelper,
+            annotation
+          );
+        } else {
+          this.renderContour(enabledElement, svgDrawingHelper, annotation);
+        }
       }
 
       // Todo: return boolean flag for each rendering route in the planar tool.

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

@@ -407,6 +407,71 @@ function renderOpenContourBeingEdited(
   );
 }
 
+/**
+ * Renders a point `PlanarFreehandROIAnnotation` annotation by drawing a circle and a crosshair
+ */
+
+function renderPointContourWithMarker(
+  enabledElement: Types.IEnabledElement,
+  svgDrawingHelper: SVGDrawingHelper,
+  annotation: PlanarFreehandROIAnnotation
+): void {
+  if (annotation.parentAnnotationUID) {
+    return;
+  }
+  const { viewport } = enabledElement;
+  const options = this._getRenderingOptions(enabledElement, annotation);
+  const canvasPolyline = annotation.data.contour.polyline.map((worldPos) =>
+    viewport.worldToCanvas(worldPos)
+  );
+  const childContours = getContourHolesDataCanvas(annotation, viewport);
+  const polylineUID = '1';
+
+  const center = canvasPolyline[0];
+  const radius = 6;
+  const numberOfPoints = 100;
+  const circlePoints = [];
+
+  for (let i = 0; i < numberOfPoints; i++) {
+    const angle = (i / numberOfPoints) * 2 * Math.PI;
+    const x = center[0] + radius * Math.cos(angle);
+    const y = center[1] + radius * Math.sin(angle);
+    circlePoints.push([x, y]);
+  }
+
+  const crosshair = [
+    [center[0] - radius * 2, center[1]],
+    [center[0] + radius * 2, center[1]],
+    [center[0], center[1] - radius * 2],
+    [center[0], center[1] + radius * 2],
+  ] as Types.Point2[];
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID + '-crosshair_v',
+    [crosshair[0], crosshair[1]],
+    options
+  );
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID + '-crosshair_h',
+    [crosshair[2], crosshair[3]],
+    options
+  );
+
+  const allContours = [circlePoints, ...childContours];
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID,
+    allContours,
+    options
+  );
+}
 /**
  * Registers the render methods of various contour states to the tool instance.
  */
@@ -414,6 +479,8 @@ function registerRenderMethods(toolInstance) {
   toolInstance.renderContour = renderContour.bind(toolInstance);
   toolInstance.renderClosedContour = renderClosedContour.bind(toolInstance);
   toolInstance.renderOpenContour = renderOpenContour.bind(toolInstance);
+  toolInstance.renderPointContourWithMarker =
+    renderPointContourWithMarker.bind(toolInstance);
   toolInstance.renderOpenUShapedContour =
     renderOpenUShapedContour.bind(toolInstance);
 

package/src/tools/displayTools/Contour/contourHandler/handleContourSegmentation.ts

@@ -163,7 +163,7 @@ function addContourSetsToElement(
         highlighted: false,
         autoGenerated: false,
         invalidated: false,
-        isLocked: false,
+        isLocked: true,
         isVisible: true,
         metadata: {
           referencedImageId: viewport.getCurrentImageId(),

package/src/types/AnnotationTypes.ts

@@ -55,9 +55,9 @@ type Annotation = {
       /** annotation text box information */
       textBox?: {
         /** whether the text box has moved */
-        hasMoved: boolean;
+        hasMoved?: boolean;
         /** the world location of the text box */
-        worldPosition: Types.Point3;
+        worldPosition?: Types.Point3;
         /** text box bounding box information */
         worldBoundingBox?: {
           /** Top left location of the text box in the world space */

package/src/utilities/annotationHydration.ts

@@ -0,0 +1,143 @@
+import {
+  Types,
+  utilities,
+  BaseVolumeViewport,
+  StackViewport,
+  cache,
+  metaData,
+} from '@cornerstonejs/core';
+import { Annotation } from '../types';
+import { addAnnotation } from '../stateManagement';
+import { vec3 } from 'gl-matrix';
+
+function annotationHydration(
+  viewport: Types.IViewport,
+  toolName: string,
+  worldPoints: Types.Point3[],
+  options?: {
+    FrameOfReferenceUID?: string;
+    annotationUID?: string;
+  }
+): Annotation {
+  const viewReference = viewport.getViewReference();
+  const { viewPlaneNormal, FrameOfReferenceUID } = viewReference;
+  const annotation = {
+    annotationUID: options?.annotationUID || utilities.uuidv4(),
+    data: {
+      handles: {
+        points: worldPoints,
+      },
+    },
+    highlighted: false,
+    autoGenerated: false,
+    invalidated: false,
+    isLocked: false,
+    isVisible: true,
+    metadata: {
+      toolName,
+      viewPlaneNormal,
+      FrameOfReferenceUID,
+      referencedImageId: getReferencedImageId(
+        viewport,
+        worldPoints[0],
+        viewPlaneNormal
+      ),
+      ...options,
+    },
+  };
+  addAnnotation(annotation, viewport.element);
+  return annotation;
+}
+
+function getReferencedImageId(
+  viewport: Types.IViewport,
+  worldPos: Types.Point3,
+  viewPlaneNormal: Types.Point3
+): string {
+  let referencedImageId;
+
+  if (viewport instanceof StackViewport) {
+    referencedImageId = getClosestImageIdForStackViewport(
+      viewport,
+      worldPos,
+      viewPlaneNormal
+    );
+  } else if (viewport instanceof BaseVolumeViewport) {
+    const targetId = getTargetId(viewport);
+    const volumeId = utilities.getVolumeId(targetId);
+    const imageVolume = cache.getVolume(volumeId);
+
+    referencedImageId = utilities.getClosestImageId(
+      imageVolume,
+      worldPos,
+      viewPlaneNormal
+    );
+  } else {
+    throw new Error(
+      'getReferencedImageId: viewport must be a StackViewport or BaseVolumeViewport'
+    );
+  }
+
+  return referencedImageId;
+}
+
+function getTargetId(viewport: Types.IViewport): string | undefined {
+  const targetId = viewport.getReferenceId?.();
+  if (targetId) {
+    return targetId;
+  }
+  if (viewport instanceof BaseVolumeViewport) {
+    return `volumeId:${getTargetVolumeId(viewport)}`;
+  }
+  throw new Error('getTargetId: viewport must have a getTargetId method');
+}
+
+function getTargetVolumeId(viewport: Types.IViewport): string | undefined {
+  const actorEntries = viewport.getActors();
+
+  if (!actorEntries) {
+    return;
+  }
+  return actorEntries.find(
+    (actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume'
+  )?.uid;
+}
+
+function getClosestImageIdForStackViewport(
+  viewport: StackViewport,
+  worldPos: Types.Point3,
+  viewPlaneNormal: Types.Point3
+): string {
+  const imageIds = viewport.getImageIds();
+  if (!imageIds || !imageIds.length) {
+    return;
+  }
+
+  const distanceImagePairs = imageIds.map((imageId) => {
+    const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+    const distance = calculateDistanceToImage(
+      worldPos,
+      imagePositionPatient,
+      viewPlaneNormal
+    );
+    return { imageId, distance };
+  });
+
+  distanceImagePairs.sort((a, b) => a.distance - b.distance);
+
+  return distanceImagePairs[0].imageId;
+}
+
+function calculateDistanceToImage(
+  worldPos: Types.Point3,
+  ImagePositionPatient: Types.Point3,
+  viewPlaneNormal: Types.Point3
+): number {
+  const dir = vec3.create();
+  vec3.sub(dir, worldPos, ImagePositionPatient);
+
+  const dot = vec3.dot(dir, viewPlaneNormal);
+
+  return Math.abs(dot);
+}
+export { annotationHydration };

package/src/utilities/index.ts

@@ -28,7 +28,7 @@ import { pointToString } from './pointToString';
 import annotationFrameRange from './annotationFrameRange';
 import pointInSurroundingSphereCallback from './pointInSurroundingSphereCallback';
 import getViewportForAnnotation from './getViewportForAnnotation';
-
+import { annotationHydration } from './annotationHydration';
 // name spaces
 import * as contours from './contours';
 import * as segmentation from './segmentation';
@@ -97,4 +97,5 @@ export {
   voi,
   annotationFrameRange,
   contourSegmentation,
+  annotationHydration,
 };