@cornerstonejs/tools 1.59.0 → 1.59.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.59.0",
+  "version": "1.59.1",
   "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.59.0",
+    "@cornerstonejs/core": "^1.59.1",
     "@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": "85e398173df425f594c5ebd4fb5cd96da9d7dbd4"
+  "gitHead": "f8957765edd911ce0e78ed21f8de92ca4b01f516"
 }

package/src/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.ts

@@ -13,6 +13,7 @@ import {
 } from '@cornerstonejs/core';
 import {
   Annotation,
+  ContourAnnotation,
   ContourSegmentationData,
   PolySegConversionOptions,
 } from '../../../../types';
@@ -256,14 +257,36 @@ function _getAnnotationMapFromSegmentation(
     ? options.segmentIndices
     : Array.from(annotationMap.keys());
 
-  const annotationUIDsInSegmentMap = new Map<number, Annotation[]>();
+  const annotationUIDsInSegmentMap = new Map<number, any>();
   segmentIndices.forEach((index) => {
     const annotationUIDsInSegment = annotationMap.get(index);
 
-    const annotations = Array.from(annotationUIDsInSegment).map((uid) => {
-      const annotation = getAnnotation(uid);
+    // Todo: there is a bug right now where the annotationUIDsInSegment has both
+    // children and parent annotations, so we need to filter out the parent
+    // annotations only
 
-      return annotation;
+    let uids = Array.from(annotationUIDsInSegment);
+
+    uids = uids.filter(
+      (uid) => !(getAnnotation(uid) as Annotation).parentAnnotationUID
+    );
+
+    const annotations = uids.map((uid) => {
+      const annotation = getAnnotation(uid) as ContourAnnotation;
+      const hasChildAnnotations = annotation.childAnnotationUIDs?.length;
+
+      return {
+        polyline: annotation.data.contour.polyline,
+        referencedImageId: annotation.metadata.referencedImageId,
+        holesPolyline:
+          hasChildAnnotations &&
+          annotation.childAnnotationUIDs.map((childUID) => {
+            const childAnnotation = getAnnotation(
+              childUID
+            ) as ContourAnnotation;
+            return childAnnotation.data.contour.polyline;
+          }),
+      };
     });
 
     annotationUIDsInSegmentMap.set(index, annotations);

package/src/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.ts

@@ -86,21 +86,15 @@ async function computeLabelmapFromContourSegmentation(
   const segmentation = getSegmentation(segmentationId);
   const representationData = segmentation.representationData.CONTOUR;
 
-  let result;
-
-  if (isVolume) {
-    result = await convertContourToVolumeLabelmap(representationData, {
-      segmentIndices,
-      segmentationRepresentationUID: options.segmentationRepresentationUID,
-      viewport: options.viewport,
-    });
-  } else {
-    result = await convertContourToStackLabelmap(representationData, {
-      segmentIndices,
-      segmentationRepresentationUID: options.segmentationRepresentationUID,
-      viewport: options.viewport,
-    });
-  }
+  const convertFunction = isVolume
+    ? convertContourToVolumeLabelmap
+    : convertContourToStackLabelmap;
+
+  const result = await convertFunction(representationData, {
+    segmentIndices,
+    segmentationRepresentationUID: options.segmentationRepresentationUID,
+    viewport: options.viewport,
+  });
 
   return result;
 }

package/src/types/ContourAnnotation.ts

@@ -21,6 +21,7 @@ export type ContourAnnotationData = {
       windingDirection?: ContourWindingDirection;
     };
   };
+  onInterpolationComplete?: () => void;
 };
 
 export type ContourAnnotation = Annotation & ContourAnnotationData;

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

@@ -74,9 +74,9 @@ function getSourceAndTargetPointsList(
     PolylineIntersectionPoint[]
   >();
 
-  const isFisrtPointInside = containsPoint(sourcePolyline, targetPolyline[0]);
+  const isFirstPointInside = containsPoint(sourcePolyline, targetPolyline[0]);
 
-  let intersectionPointDirection = isFisrtPointInside
+  let intersectionPointDirection = isFirstPointInside
     ? PolylinePointDirection.Exiting
     : PolylinePointDirection.Entering;
 

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

@@ -17,7 +17,12 @@ import isClosed from './isClosed';
 export default function containsPoint(
   polyline: Types.Point2[],
   point: Types.Point2,
-  closed?: boolean
+  options: {
+    closed?: boolean;
+    holes?: Types.Point2[][];
+  } = {
+    closed: undefined,
+  }
 ): boolean {
   if (polyline.length < 3) {
     return false;
@@ -26,6 +31,16 @@ export default function containsPoint(
   const numPolylinePoints = polyline.length;
   let numIntersections = 0;
 
+  const { closed, holes } = options;
+
+  if (holes?.length) {
+    for (const hole of holes) {
+      if (containsPoint(hole, point)) {
+        return false;
+      }
+    }
+  }
+
   // Test intersection against [end, start] line segment if it should be closed
   const shouldClose = !(closed === undefined ? isClosed(polyline) : closed);
   const maxSegmentIndex = polyline.length - (shouldClose ? 1 : 2);

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

@@ -19,6 +19,7 @@ import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourP
 import addCanvasPointsToArray from './addCanvasPointsToArray';
 import pointCanProjectOnLine from './pointCanProjectOnLine';
 import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
+import { projectTo2D } from './projectTo2D';
 
 export {
   isClosed,
@@ -43,4 +44,5 @@ export {
   mergePolylines,
   subtractPolylines,
   isPointInsidePolyline3D,
+  projectTo2D,
 };

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

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import containsPoint from './containsPoint';
+import { projectTo2D } from './projectTo2D';
 
 /**
  * Determines whether a 3D point is inside a polyline in 3D space.
@@ -9,42 +10,35 @@ import containsPoint from './containsPoint';
  *
  * @param point - The 3D point to test.
  * @param polyline - The polyline represented as an array of 3D points.
+ * @param options.holesPolyline - An array of polylines representing each hole, so it
+ * is an array of arrays of 3D points.
  * @returns A boolean indicating whether the point is inside the polyline.
  * @throws An error if a shared dimension index cannot be found for the polyline points.
  */
 export function isPointInsidePolyline3D(
   point: Types.Point3,
-  polyline: Types.Point3[]
+  polyline: Types.Point3[],
+  options: { holes?: Types.Point3[][] } = {}
 ) {
-  // Todo: handle oblique planes
+  const { sharedDimensionIndex, projectedPolyline } = projectTo2D(polyline);
 
-  // We need to reduce one dimension to 2D, so basically
-  // we need to find the dimension index that is shared by all points
-  // Use the first three points, two is enough but three is more robust
-  let sharedDimensionIndex;
+  const { holes } = options;
+  const projectedHoles = [] as Types.Point2[][];
 
-  const testPoints = polyline.slice(0, 3);
-  for (let i = 0; i < 3; i++) {
-    if (testPoints.every((point, index, array) => point[i] === array[0][i])) {
-      sharedDimensionIndex = i;
-      break;
-    }
-  }
+  if (holes) {
+    for (let i = 0; i < holes.length; i++) {
+      const hole = holes[i];
+      const hole2D = [] as Types.Point2[];
 
-  if (sharedDimensionIndex === undefined) {
-    throw new Error(
-      'Cannot find a shared dimension index for polyline, probably oblique plane'
-    );
-  }
+      for (let j = 0; j < hole.length; j++) {
+        hole2D.push([
+          hole[j][(sharedDimensionIndex + 1) % 3],
+          hole[j][(sharedDimensionIndex + 2) % 3],
+        ]);
+      }
 
-  // convert polyline list and point to 2D
-  const points2D = [] as Types.Point2[];
-
-  for (let i = 0; i < polyline.length; i++) {
-    points2D.push([
-      polyline[i][(sharedDimensionIndex + 1) % 3],
-      polyline[i][(sharedDimensionIndex + 2) % 3],
-    ]);
+      projectedHoles.push(hole2D);
+    }
   }
 
   const point2D = [
@@ -52,5 +46,5 @@ export function isPointInsidePolyline3D(
     point[(sharedDimensionIndex + 2) % 3],
   ] as Types.Point2;
 
-  return containsPoint(points2D, point2D);
+  return containsPoint(projectedPolyline, point2D, { holes: projectedHoles });
 }

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

@@ -0,0 +1,52 @@
+import { utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+const epsilon = 1e-6;
+
+/**
+ * Projects a polyline from 3D to 2D by reducing one dimension.
+ *
+ * @param polyline - The polyline to be projected.
+ * @returns An object containing the shared dimension index and the projected polyline in 2D.
+ * @throws Error if a shared dimension index cannot be found for the polyline.
+ */
+export function projectTo2D(polyline: Types.Point3[]) {
+  // We need to reduce one dimension to 2D, so basically
+  // we need to find the dimension index that is shared by all points
+  // Use the first three points, two is enough but three is more robust
+  let sharedDimensionIndex;
+
+  const testPoints = utilities.getRandomSampleFromArray(polyline, 50);
+
+  for (let i = 0; i < 3; i++) {
+    if (
+      testPoints.every(
+        (point, index, array) => Math.abs(point[i] - array[0][i]) < epsilon
+      )
+    ) {
+      sharedDimensionIndex = i;
+      break;
+    }
+  }
+
+  if (sharedDimensionIndex === undefined) {
+    throw new Error(
+      'Cannot find a shared dimension index for polyline, probably oblique plane'
+    );
+  }
+
+  // convert polyline list and point to 2D
+  const points2D = [] as Types.Point2[];
+
+  const firstDim = (sharedDimensionIndex + 1) % 3;
+  const secondDim = (sharedDimensionIndex + 2) % 3;
+
+  for (let i = 0; i < polyline.length; i++) {
+    points2D.push([polyline[i][firstDim], polyline[i][secondDim]]);
+  }
+
+  return {
+    sharedDimensionIndex,
+    projectedPolyline: points2D,
+  };
+}

package/src/workers/polySegConverters.js

@@ -10,7 +10,12 @@ import vtkCutter from '@kitware/vtk.js/Filters/Core/Cutter';
 
 import { getBoundingBoxAroundShapeWorld } from '../utilities/boundingBox';
 import { pointInShapeCallback } from '../utilities';
-import { getAABB, isPointInsidePolyline3D } from '../utilities/math/polyline';
+import {
+  containsPoint,
+  getAABB,
+  isPointInsidePolyline3D,
+  projectTo2D,
+} from '../utilities/math/polyline';
 import { isPlaneIntersectingAABB } from '../utilities/planar';
 
 /**
@@ -161,9 +166,12 @@ const polySegConverters = {
       const annotations = annotationUIDsInSegmentMap.get(index);
 
       for (const annotation of annotations) {
-        const bounds = getBoundingBoxAroundShapeWorld(
-          annotation.data.contour.polyline
-        );
+        if (!annotation.polyline) {
+          continue;
+        }
+
+        const { polyline, holesPolyline } = annotation;
+        const bounds = getBoundingBoxAroundShapeWorld(polyline);
 
         const [iMin, jMin, kMin] = utilities.transformWorldToIndex(imageData, [
           bounds[0][0],
@@ -177,15 +185,29 @@ const polySegConverters = {
           bounds[2][1],
         ]);
 
+        const { projectedPolyline, sharedDimensionIndex } =
+          projectTo2D(polyline);
+
+        const holes = holesPolyline?.map((hole) => {
+          const { projectedPolyline: projectedHole } = projectTo2D(hole);
+          return projectedHole;
+        });
+
+        const firstDim = (sharedDimensionIndex + 1) % 3;
+        const secondDim = (sharedDimensionIndex + 2) % 3;
+
         // Run the pointInShapeCallback for the combined bounding box
         pointInShapeCallback(
           imageData,
           (pointLPS) => {
+            const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
+
             // Check if the point is inside any of the polylines for this segment
-            return isPointInsidePolyline3D(
-              pointLPS,
-              annotation.data.contour.polyline
-            );
+            const isInside = containsPoint(projectedPolyline, point2D, {
+              holes,
+            });
+
+            return isInside;
           },
           ({ pointIJK }) => {
             segmentationVoxelManager.setAtIJKPoint(pointIJK, index);
@@ -250,14 +272,12 @@ const polySegConverters = {
       const annotations = annotationUIDsInSegmentMap.get(index);
 
       for (const annotation of annotations) {
-        if (!annotation?.data) {
+        if (!annotation.polyline) {
           continue;
         }
-        const bounds = getBoundingBoxAroundShapeWorld(
-          annotation.data.contour.polyline
-        );
 
-        const { referencedImageId } = annotation.metadata;
+        const { polyline, holesPolyline, referencedImageId } = annotation;
+        const bounds = getBoundingBoxAroundShapeWorld(polyline);
 
         const { manager: segmentationVoxelManager, imageData } =
           segmentationVoxelManagers.get(referencedImageId);
@@ -274,15 +294,29 @@ const polySegConverters = {
           bounds[2][1],
         ]);
 
+        const { projectedPolyline, sharedDimensionIndex } =
+          projectTo2D(polyline);
+
+        const holes = holesPolyline?.map((hole) => {
+          const { projectedPolyline: projectedHole } = projectTo2D(hole);
+          return projectedHole;
+        });
+
+        const firstDim = (sharedDimensionIndex + 1) % 3;
+        const secondDim = (sharedDimensionIndex + 2) % 3;
+
         // Run the pointInShapeCallback for the combined bounding box
         pointInShapeCallback(
           imageData,
           (pointLPS) => {
+            const point2D = [pointLPS[firstDim], pointLPS[secondDim]];
+
             // Check if the point is inside any of the polylines for this segment
-            return isPointInsidePolyline3D(
-              pointLPS,
-              annotation.data.contour.polyline
-            );
+            const isInside = containsPoint(projectedPolyline, point2D, {
+              holes,
+            });
+
+            return isInside;
           },
           ({ pointIJK }) => {
             segmentationVoxelManager.setAtIJKPoint(pointIJK, index);