@cornerstonejs/tools 1.70.14 → 1.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.70.14",
+  "version": "1.71.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.70.14",
+    "@cornerstonejs/core": "^1.71.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": "e511c3f4b11596cfedb30b071b42c9c68d71d018"
+  "gitHead": "03c01970a50a7383de86bb15c8d4f344a8ff7d25"
 }

package/src/index.ts

@@ -71,6 +71,7 @@ import {
   OverlayGridTool,
   SegmentationIntersectionTool,
   EraserTool,
+  SculptorTool,
   SegmentSelectTool,
 } from './tools';
 
@@ -128,6 +129,7 @@ export {
   ReferenceCursors,
   ReferenceLines,
   ScaleOverlayTool,
+  SculptorTool,
   EraserTool,
   // Segmentation Display
   SegmentationDisplayTool,

package/src/synchronizers/synchronizers/createVOISynchronizer.ts

@@ -5,7 +5,7 @@ import Synchronizer from '../../store/SynchronizerManager/Synchronizer';
 
 type VOISynchronizerOptions = {
   syncInvertState: boolean;
-  syncColormap :boolean;
+  syncColormap: boolean;
 };
 
 /**
@@ -24,7 +24,10 @@ export default function createVOISynchronizer(
   options: VOISynchronizerOptions
 ): Synchronizer {
   //  = { syncInvertState: true } if options is not provided or undefined or {}
-  options = Object.assign({ syncInvertState: true, syncColormap:true }, options);
+  options = Object.assign(
+    { syncInvertState: true, syncColormap: true },
+    options
+  );
 
   const VOISynchronizer = createSynchronizer(
     synchronizerName,

package/src/tools/OrientationMarkerTool.ts

@@ -170,10 +170,14 @@ class OrientationMarkerTool extends BaseTool {
         const resizeObserver = new ResizeObserver(() => {
           // Todo: i wish there was a better way to do this
           setTimeout(() => {
-            const { viewport } = getEnabledElementByIds(
+            const element = getEnabledElementByIds(
               viewportId,
               renderingEngineId
             );
+            if (!element) {
+              return;
+            }
+            const { viewport } = element;
             this.resize(viewportId);
             viewport.render();
           }, 100);

package/src/tools/SculptorTool/CircleSculptCursor.ts

@@ -0,0 +1,212 @@
+import type { Types } from '@cornerstonejs/core';
+import { getEnabledElement } from '@cornerstonejs/core';
+import { ISculptToolShape } from '../../types/ISculptToolShape';
+import { SculptData } from '../SculptorTool';
+import { distancePointToContour } from '../distancePointToContour';
+import { drawCircle as drawCircleSvg } from '../../drawingSvg';
+import { point } from '../../utilities/math';
+import {
+  SVGDrawingHelper,
+  EventTypes,
+  ContourAnnotationData,
+} from '../../types';
+
+export type PushedHandles = {
+  first?: number;
+  last?: number;
+};
+
+/**
+ * Implements a dynamic radius circle sculpt tool to edit contour annotations.
+ * This tool changes radius based on the nearest point on a contour tool.
+ *
+ * TODO: Update this tool to allow modifying spline and other handle containing
+ * contours.
+ */
+class CircleSculptCursor implements ISculptToolShape {
+  static shapeName = 'Circle';
+
+  private toolInfo = {
+    toolSize: null,
+    maxToolSize: null,
+  };
+
+  /**
+   * Renders a circle at the current sculpt tool location
+   */
+  renderShape(
+    svgDrawingHelper: SVGDrawingHelper,
+    canvasLocation: Types.Point2,
+    options: any
+  ): void {
+    const circleUID = '0';
+    drawCircleSvg(
+      svgDrawingHelper,
+      'SculptorTool',
+      circleUID,
+      canvasLocation,
+      this.toolInfo.toolSize,
+      options
+    );
+  }
+
+  /**
+   * Pushes the points radially away from the mouse if they are
+   * contained within the shape defined by the freehandSculpter tool
+   */
+  pushHandles(
+    viewport: Types.IViewport,
+    sculptData: SculptData
+  ): PushedHandles {
+    const { points, mouseCanvasPoint } = sculptData;
+    const pushedHandles: PushedHandles = { first: undefined, last: undefined };
+
+    for (let i = 0; i < points.length; i++) {
+      const handleCanvasPoint = viewport.worldToCanvas(points[i]);
+      const distanceToHandle = point.distanceToPoint(
+        handleCanvasPoint,
+        mouseCanvasPoint
+      );
+
+      if (distanceToHandle > this.toolInfo.toolSize) {
+        continue;
+      }
+
+      // Push point if inside circle, to edge of circle.
+      this.pushOneHandle(i, distanceToHandle, sculptData);
+      if (pushedHandles.first === undefined) {
+        pushedHandles.first = i;
+        pushedHandles.last = i;
+      } else {
+        pushedHandles.last = i;
+      }
+    }
+
+    return pushedHandles;
+  }
+
+  /**
+   * Sets up the basic tool size from the element, where the tool size
+   * is set at minimum to 1/12 of the minimum of the width and height.
+   */
+  configureToolSize(evt: EventTypes.InteractionEventType): void {
+    const toolInfo = this.toolInfo;
+
+    if (toolInfo.toolSize && toolInfo.maxToolSize) {
+      return;
+    }
+
+    const eventData = evt.detail;
+    const element = eventData.element;
+    const minDim = Math.min(element.clientWidth, element.clientHeight);
+    const maxRadius = minDim / 12;
+
+    toolInfo.toolSize = maxRadius;
+    toolInfo.maxToolSize = maxRadius;
+  }
+
+  /**
+   * Adjusts the tool size based on computing the nearest point to the active
+   * annotation object, and using the distance to the cursor point, clipping that
+   * to at most the configured radius.
+   */
+  updateToolSize(
+    canvasCoords: Types.Point2,
+    viewport: Types.IViewport,
+    activeAnnotation: ContourAnnotationData
+  ): void {
+    const toolInfo = this.toolInfo;
+    const radius = distancePointToContour(
+      viewport,
+      activeAnnotation,
+      canvasCoords
+    );
+    if (radius > 0) {
+      toolInfo.toolSize = Math.min(toolInfo.maxToolSize, radius);
+    }
+  }
+
+  /**
+   * Returns the maximum spacing between handles for this tool adjustment.
+   */
+  getMaxSpacing(minSpacing: number): number {
+    return Math.max(this.toolInfo.toolSize / 4, minSpacing);
+  }
+
+  /**
+   * Returns the index position of data to start inserting new tool information
+   * into the freeform.
+   */
+  getInsertPosition(
+    previousIndex: number,
+    nextIndex: number,
+    sculptData: SculptData
+  ): Types.Point3 {
+    let insertPosition: Types.Point2;
+    const { points, element, mouseCanvasPoint } = sculptData;
+    const toolSize = this.toolInfo.toolSize;
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+    const previousCanvasPoint = viewport.worldToCanvas(points[previousIndex]);
+    const nextCanvasPoint = viewport.worldToCanvas(points[nextIndex]);
+
+    const midPoint: Types.Point2 = [
+      (previousCanvasPoint[0] + nextCanvasPoint[0]) / 2.0,
+      (previousCanvasPoint[1] + nextCanvasPoint[1]) / 2.0,
+    ];
+
+    const distanceToMidPoint = point.distanceToPoint(
+      mouseCanvasPoint,
+      midPoint
+    );
+
+    if (distanceToMidPoint < toolSize) {
+      const directionUnitVector = {
+        x: (midPoint[0] - mouseCanvasPoint[0]) / distanceToMidPoint,
+        y: (midPoint[1] - mouseCanvasPoint[1]) / distanceToMidPoint,
+      };
+
+      insertPosition = [
+        mouseCanvasPoint[0] + toolSize * directionUnitVector.x,
+        mouseCanvasPoint[1] + toolSize * directionUnitVector.y,
+      ];
+    } else {
+      insertPosition = midPoint;
+    }
+
+    const worldPosition = viewport.canvasToWorld(insertPosition);
+
+    return worldPosition;
+  }
+
+  /**
+   * Adds a new point into the sculpt data.
+   */
+  private pushOneHandle(
+    i: number,
+    distanceToHandle: number,
+    sculptData: SculptData
+  ): void {
+    const { points, mousePoint } = sculptData;
+    const toolSize = this.toolInfo.toolSize;
+    const handle = points[i];
+
+    const directionUnitVector = {
+      x: (handle[0] - mousePoint[0]) / distanceToHandle,
+      y: (handle[1] - mousePoint[1]) / distanceToHandle,
+      z: (handle[2] - mousePoint[2]) / distanceToHandle,
+    };
+
+    const position = {
+      x: mousePoint[0] + toolSize * directionUnitVector.x,
+      y: mousePoint[1] + toolSize * directionUnitVector.y,
+      z: mousePoint[2] + toolSize * directionUnitVector.z,
+    };
+
+    handle[0] = position.x;
+    handle[1] = position.y;
+    handle[2] = position.z;
+  }
+}
+
+export default CircleSculptCursor;