@cornerstonejs/tools 1.84.0 → 1.84.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.84.0",
+  "version": "1.84.2",
   "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.84.0",
+    "@cornerstonejs/core": "^1.84.2",
     "@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": "642bbba3dbb8ded72994e30759d029bed7adfd04"
+  "gitHead": "79667170db3c7d65acfcea1359c06b3f74763b40"
 }

package/src/utilities/planarFreehandROITool/smoothAnnotation.ts

@@ -1,88 +1,131 @@
 import { Types } from '@cornerstonejs/core';
+import { mat4, vec3 } from 'gl-matrix';
 import { PlanarFreehandROITool } from '../../tools';
 import { ToolGroupManager } from '../../store';
 import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
 
+export type SmoothOptions = {
+  knotsRatioPercentage: number;
+  loop: number;
+};
+
 function shouldPreventInterpolation(
-  enabledElement: Types.IEnabledElement,
   annotation: PlanarFreehandROIAnnotation,
-  knotsRatioPercentage: number
+  options?: SmoothOptions
 ): boolean {
-  if (!annotation?.data?.polyline || knotsRatioPercentage <= 0) {
+  const knotsRatioPercentage = options?.knotsRatioPercentage || 30;
+  if (
+    !annotation?.data?.contour?.polyline?.length ||
+    knotsRatioPercentage <= 0
+  ) {
     return true;
   }
 
-  if (!enabledElement.viewport) {
-    return true;
-  }
+  return false;
+}
 
-  const { renderingEngineId, viewportId, FrameOfReferenceUID } = enabledElement;
-  const toolGroup = ToolGroupManager.getToolGroupForViewport(
-    viewportId,
-    renderingEngineId
-  );
+function rotateMatrix(normal, focal) {
+  const mat = mat4.create();
+  const eye = vec3.add(vec3.create(), focal, normal);
+  const up =
+    Math.abs(normal[0]) > 0.1
+      ? vec3.fromValues(-normal[1], normal[0], 0)
+      : vec3.fromValues(0, -normal[2], normal[1]);
+  // Use the focal point as the "eye" position so that the focal point get rotated to 0 for the k coordinate.
+  mat4.lookAt(mat, focal, eye, up);
+  return mat;
+}
 
-  if (annotation.metadata.FrameOfReferenceUID !== FrameOfReferenceUID) {
-    return true;
+/**
+ * Rotate the array to prevent interpolation at endpoints causing non-smooth endpoints
+ * Rotates the list in place.
+ */
+function rotate(list, count = Math.floor(Math.random() * (list.length - 1))) {
+  if (count === 0) {
+    return 0;
   }
-
-  if (!toolGroup) {
-    return true;
+  const srcList = [...list];
+  const { length } = list;
+  for (let i = 0; i < length; i++) {
+    list[i] = srcList[(i + count + length) % length];
   }
-
-  const toolInstance = toolGroup.getToolInstance(annotation.metadata.toolName);
-
-  // strategy to prevent non PlanarFreehandTool
-  if (!(toolInstance instanceof PlanarFreehandROITool)) {
-    return true;
-  }
-
-  return (
-    toolInstance.isDrawing ||
-    toolInstance.isEditingOpen ||
-    toolInstance.isEditingClosed
-  );
+  return count;
 }
+
 /**
  * Interpolates a given annotation from a given enabledElement.
  * It mutates annotation param.
- * The param knotsRatioPercentage defines the percentage of points to be considered as knots on the interpolation process.
- * Interpolation will be skipped in case: annotation is not present in enabledElement (or there is no toolGroup associated with it), related tool is being modified.
+ * The param options.knotsRatioPercentage defines the percentage of points to be considered as knots on the interpolation process.
+ * The param options.loop can be set to run smoothing repeatedly.  This results in
+ * additional smoothing.
+ * This works by translating the annotation into the view plane normal orientation, with a zero k component, and then
+ * performing the smoothing in-plane, and converting back to the original orientation.
+ * Closed polylines are smoothed at a random starting spot in order to prevent
+ * the start/end points from not being smoothed.
+ *
+ * Note that each smoothing iteration will reduce the size of the annotation, particularly
+ * for closed annotations.  This occurs because a smaller/rounder annotation is smoother
+ * in some sense than the original.
  */
 export default function smoothAnnotation(
-  enabledElement: Types.IEnabledElement,
   annotation: PlanarFreehandROIAnnotation,
-  knotsRatioPercentage: number
+  options?: SmoothOptions
 ): boolean {
   // prevent running while there is any tool annotation being modified
-  if (
-    shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercentage)
-  ) {
+  if (shouldPreventInterpolation(annotation, options)) {
     return false;
   }
 
-  const { viewport } = enabledElement;
+  const { viewPlaneNormal } = annotation.metadata;
+  const { closed, polyline } = annotation.data.contour;
+
   // use only 2 dimensions on interpolation (what visually matters),
   // otherwise a 3d interpolation might have a totally different output as it consider one more dimension.
-  const canvasPoints = annotation.data.contour.polyline.map(
-    viewport.worldToCanvas
+  const rotateMat = rotateMatrix(
+    viewPlaneNormal,
+    annotation.data.contour.polyline[0]
+  );
+  const canvasPoints = <Types.Point2[]>annotation.data.contour.polyline.map(
+    (p) => {
+      const planeP = vec3.transformMat4(vec3.create(), p, rotateMat);
+      return [planeP[0], planeP[1]];
+    }
   );
-  const interpolatedCanvasPoints = <Types.Point2[]>(
+  let rotation = closed ? rotate(canvasPoints) : 0;
+  let interpolatedCanvasPoints = <Types.Point2[]>(
     interpolateSegmentPoints(
       canvasPoints,
       0,
       canvasPoints.length,
-      knotsRatioPercentage
+      options?.knotsRatioPercentage || 30
     )
   );
 
   if (interpolatedCanvasPoints === canvasPoints) {
     return false;
   }
+  // Reverse the rotation so that handles still line up.
+  rotate(interpolatedCanvasPoints, -rotation);
 
-  annotation.data.contour.polyline = interpolatedCanvasPoints.map(
-    viewport.canvasToWorld
+  for (let i = 1; i < options?.loop; i++) {
+    rotation = closed ? rotate(interpolatedCanvasPoints) : 0;
+    interpolatedCanvasPoints = <Types.Point2[]>(
+      interpolateSegmentPoints(
+        interpolatedCanvasPoints,
+        0,
+        canvasPoints.length,
+        options?.knotsRatioPercentage || 30
+      )
+    );
+    rotate(interpolatedCanvasPoints, -rotation);
+  }
+
+  const unRotate = mat4.invert(mat4.create(), rotateMat);
+  annotation.data.contour.polyline = <Types.Point3[]>(
+    interpolatedCanvasPoints.map((p) =>
+      vec3.transformMat4([0, 0, 0], [...p, 0], unRotate)
+    )
   );
 
   return true;