@cornerstonejs/tools 1.57.1 → 1.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.57.1",
+  "version": "1.58.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.57.1",
+    "@cornerstonejs/core": "^1.58.0",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
@@ -41,7 +41,7 @@
   },
   "peerDependencies": {
     "@icr/polyseg-wasm": "0.4.0",
-    "@kitware/vtk.js": "29.3.0",
+    "@kitware/vtk.js": "29.7.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
     "d3-array": "^3.2.3",
@@ -59,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f0b7bf4653169cad680753b9d79556b5998b5758"
+  "gitHead": "4efc255a96d8855affdec84d2617db15041496c0"
 }

package/src/drawingSvg/drawPath.ts

@@ -61,7 +61,9 @@ export default function drawPath(
       const point = points[j];
       const cmd = j ? 'L' : 'M';
 
-      pointsAttribute += `${cmd} ${point[0]},${point[1]} `;
+      pointsAttribute += `${cmd} ${point[0].toFixed(1)}, ${point[1].toFixed(
+        1
+      )} `;
     }
 
     if (closePath) {

package/src/enums/WorkerTypes.ts

@@ -10,7 +10,7 @@ enum ChangeTypes {
 
   POLYSEG_LABELMAP_TO_SURFACE = 'polySeg/convertLabelmapToSurface',
 
-  DISPLAY_TOOL_CLIP_SURFACE = 'displayTool/clipSurface',
+  SURFACE_CLIPPING = 'surfaceClipping',
 }
 
 export default ChangeTypes;

package/src/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.ts

@@ -0,0 +1,203 @@
+import {
+  Types,
+  Enums,
+  getWebWorkerManager,
+  eventTarget,
+  triggerEvent,
+} from '@cornerstonejs/core';
+
+import { WorkerTypes } from '../../../enums';
+import { pointToString } from '../../../utilities';
+import { registerPolySegWorker } from '../polySeg/registerPolySegWorker';
+const workerManager = getWebWorkerManager();
+
+/**
+ * Surfaces info for clipping
+ */
+export type SurfacesInfo = {
+  id: string;
+  points: number[];
+  polys: number[];
+  segmentIndex: number;
+};
+
+/**
+ * The result of the surface clipping
+ */
+export type SurfaceClipResult = {
+  points: number[];
+  lines: number[];
+  numberOfCells: number;
+};
+
+export type PolyDataClipCacheType = Map<string, Map<string, SurfaceClipResult>>;
+
+/**
+ * a cache from actorUID to cacheId to SurfaceClipResult
+ * Map<actorUID, Map<cacheId, SurfaceClipResult>>
+ * cacheId is slice specific (viewPlaneNormal, sliceIndex)
+ */
+const polyDataCache = new Map() as PolyDataClipCacheType;
+const surfacesAABBCache = new Map();
+
+const triggerWorkerProgress = (eventTarget, progress) => {
+  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+    progress,
+    type: WorkerTypes.SURFACE_CLIPPING,
+  });
+};
+
+/**
+ * Clips and caches surfaces for a specific viewport.
+ *
+ * @param surfacesInfo - An array of surfaces information.
+ * @param viewport - The volume viewport.
+ * @param segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns The cached polydata.
+ */
+export async function clipAndCacheSurfacesForViewport(
+  surfacesInfo: SurfacesInfo[],
+  viewport: Types.IVolumeViewport,
+  segmentationRepresentationUID: string
+) {
+  registerPolySegWorker();
+  // All planes is an array of planes pairs for each slice, so we should loop over them and
+  // add the planes to the clipping filter and cache the results for that slice
+
+  // Fix these ts ignores
+  // @ts-ignore
+  const planesInfo = viewport.getSlicesClippingPlanes?.();
+
+  if (!planesInfo) {
+    // this means it is probably the stack viewport not being ready
+    // in terms of planes which we should wait for the first render to
+    // get the planes
+    return;
+  }
+
+  // @ts-ignore
+  const currentSliceIndex = viewport.getSliceIndex();
+
+  // Reorder planesInfo based on proximity to currentSliceIndex
+  planesInfo.sort((a, b) => {
+    const diffA = Math.abs(a.sliceIndex - currentSliceIndex);
+    const diffB = Math.abs(b.sliceIndex - currentSliceIndex);
+    return diffA - diffB;
+  });
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  // check which surfaces don't have a cached AABB
+  // make a list of the surfaces that don't have a cached AABB
+  await updateSurfacesAABBCache(surfacesInfo);
+
+  const surfacesAABB = new Map();
+  surfacesInfo.forEach((surface) => {
+    surfacesAABB.set(surface.id, surfacesAABBCache.get(surface.id));
+  });
+
+  const camera = viewport.getCamera();
+
+  await workerManager
+    .executeTask(
+      'polySeg',
+      'cutSurfacesIntoPlanes',
+      {
+        surfacesInfo,
+        planesInfo,
+        surfacesAABB,
+      },
+      {
+        callbacks: [
+          // progress callback
+          ({ progress }) => {
+            triggerWorkerProgress(eventTarget, progress);
+          },
+          // update cache callback
+          ({ sliceIndex, polyDataResults }) => {
+            polyDataResults.forEach((polyDataResult, surfaceId) => {
+              const actorUID = `${segmentationRepresentationUID}_${surfaceId}`;
+              const cacheId = generateCacheId(
+                viewport,
+                camera.viewPlaneNormal,
+                sliceIndex
+              );
+              updatePolyDataCache(actorUID, cacheId, polyDataResult);
+            });
+          },
+        ],
+      }
+    )
+    .catch((error) => {
+      console.error(error);
+    });
+
+  triggerWorkerProgress(eventTarget, 1);
+
+  return polyDataCache;
+}
+
+/**
+ * Updates the surfaces AABB cache with the AABB information for the given surfaces.
+ * If the AABB information for a surface already exists in the cache, it will not be updated.
+ * @param surfacesInfo - An array of surfaces information.
+ * @returns A Promise that resolves when the surfaces AABB cache has been updated.
+ */
+async function updateSurfacesAABBCache(surfacesInfo: SurfacesInfo[]) {
+  const surfacesWithoutAABB = surfacesInfo.filter(
+    (surface) => !surfacesAABBCache.has(surface.id)
+  );
+
+  if (!surfacesWithoutAABB.length) {
+    return;
+  }
+
+  const surfacesAABB = await workerManager.executeTask(
+    'polySeg',
+    'getSurfacesAABBs',
+    {
+      surfacesInfo: surfacesWithoutAABB,
+    },
+    {
+      callbacks: [
+        // progress callback
+        ({ progress }) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  // update the surfacesAABBCache with the new surfacesAABB
+  surfacesAABB.forEach((aabb, id) => {
+    surfacesAABBCache.set(id, aabb);
+  });
+}
+
+export function getSurfaceActorUID(
+  segmentationRepresentationUID: string,
+  surfaceId: string
+) {
+  return `${segmentationRepresentationUID}_${surfaceId}`;
+}
+
+// Helper function to generate a cache ID
+export function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
+  return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
+}
+
+// Helper function to update PolyData cache
+export function updatePolyDataCache(
+  actorUID: string,
+  cacheId: string,
+  polyDataResult: SurfaceClipResult
+) {
+  const { points, lines, numberOfCells } = polyDataResult;
+
+  let actorCache = polyDataCache.get(actorUID);
+  if (!actorCache) {
+    actorCache = new Map<string, SurfaceClipResult>();
+    polyDataCache.set(actorUID, actorCache);
+  }
+  actorCache.set(cacheId, { points, lines, numberOfCells });
+}

package/src/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.ts

@@ -1,5 +1,7 @@
+import { SegmentationRepresentations } from '../../../../enums';
 import { PolySegConversionOptions } from '../../../../types';
-
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeContourData } from './contourComputationStrategies';
 /**
  * Computes and adds the contour representation for a given segmentation.
  *
@@ -13,5 +15,10 @@ export function computeAndAddContourRepresentation(
   segmentationId: string,
   options: PolySegConversionOptions = {}
 ) {
-  throw new Error('Not implemented yet');
+  return computeAndAddRepresentation(
+    segmentationId,
+    SegmentationRepresentations.Contour,
+    () => computeContourData(segmentationId, options),
+    () => undefined
+  );
 }

package/src/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.ts

@@ -0,0 +1,201 @@
+import { cache } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import {
+  getSegmentation,
+  setSegmentationRepresentationSpecificConfig,
+} from '../../segmentationState';
+import { PolySegConversionOptions } from '../../../../types';
+import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
+import {
+  SurfaceClipResult,
+  clipAndCacheSurfacesForViewport,
+} from '../../helpers/clipAndCacheSurfacesForViewport';
+import { extractContourData } from './utils/extractContourData';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
+import { getToolGroupForViewport } from '../../../../store/ToolGroupManager';
+
+// the map between segment index and the intersection points and lines
+export type RawContourData = Map<number, SurfaceClipResult[]>;
+
+/**
+ * Computes contour data for a given segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for the computation.
+ * @returns An object containing the annotation UIDs map.
+ * @throws Error if there is not enough data to convert to contour.
+ */
+export async function computeContourData(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  let rawContourData: RawContourData;
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData;
+
+  try {
+    if (representationData.SURFACE) {
+      rawContourData = await computeContourFromSurfaceSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    } else if (representationData.LABELMAP) {
+      rawContourData = await computeContourFromLabelmapSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    }
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+
+  if (!rawContourData) {
+    throw new Error(
+      'Not enough data to convert to contour, currently only support converting volume labelmap to contour if available'
+    );
+  }
+
+  const { viewport, segmentationRepresentationUID } = options;
+
+  // create the new annotations and add them to the segmentation state representation
+  // data for the contour representation
+  const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(
+    rawContourData,
+    viewport,
+    segmentationId
+  );
+
+  // make the segmentation configuration fillAlpha 0 since
+  // we don't have proper hole support right now
+  // Todo: add hole support
+  const toolGroupId = getToolGroupForViewport(viewport.id)?.id;
+
+  setSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    {
+      CONTOUR: {
+        fillAlpha: 0,
+      },
+    }
+  );
+
+  return {
+    annotationUIDsMap,
+  };
+}
+
+/**
+ * Computes the contour from a labelmap segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - The options for the contour computation.
+ * @returns The raw contour data.
+ */
+async function computeContourFromLabelmapSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+) {
+  if (!options.viewport) {
+    throw new Error('Viewport is required to compute contour from labelmap');
+  }
+
+  const results = await computeSurfaceFromLabelmapSegmentation(
+    segmentationId,
+    options
+  );
+
+  if (!results?.length) {
+    console.error('Failed to convert labelmap to surface or labelmap is empty');
+    return;
+  }
+
+  const { viewport, segmentationRepresentationUID } = options;
+
+  const pointsAndPolys = results.map((surface) => {
+    return {
+      id: surface.segmentIndex.toString(),
+      points: surface.data.points,
+      polys: surface.data.polys,
+      segmentIndex: surface.segmentIndex,
+    };
+  });
+
+  const polyDataCache = await clipAndCacheSurfacesForViewport(
+    pointsAndPolys,
+    viewport as Types.IVolumeViewport,
+    segmentationRepresentationUID
+  );
+
+  const rawResults = extractContourData(polyDataCache);
+
+  return rawResults;
+}
+
+/**
+ * Computes the contour from a surface segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - The options for the contour computation.
+ * @returns A promise that resolves to the raw contour data.
+ * @throws An error if the viewport is not provided.
+ */
+async function computeContourFromSurfaceSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+): Promise<RawContourData> {
+  if (!options.viewport) {
+    throw new Error('Viewport is required to compute contour from surface');
+  }
+  const { viewport, segmentationRepresentationUID } = options;
+
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  const segmentIndexToSurfaceId = new Map() as Map<number, string>;
+  const surfaceIdToSegmentIndex = new Map() as Map<string, number>;
+
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData.SURFACE;
+
+  const surfacesInfo = [];
+  representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+    if (segmentIndices.includes(segmentIndex)) {
+      segmentIndexToSurfaceId.set(segmentIndex, geometryId);
+      const surface = cache.getGeometry(geometryId)?.data as Types.ISurface;
+      if (surface) {
+        surfacesInfo.push({
+          id: geometryId,
+          points: surface.getPoints(),
+          polys: surface.getPolys(),
+        });
+      }
+    }
+  });
+
+  segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
+    surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
+  });
+
+  const polyDataCache = await clipAndCacheSurfacesForViewport(
+    surfacesInfo,
+    viewport as Types.IVolumeViewport,
+    segmentationRepresentationUID
+  );
+
+  const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
+
+  return rawResults;
+}
+
+export { computeContourFromLabelmapSegmentation };

package/src/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.ts

@@ -0,0 +1,103 @@
+import { PlanarFreehandContourSegmentationTool } from '../../../../../tools';
+import { addAnnotation } from '../../../../annotation/annotationState';
+import { RawContourData } from '../contourComputationStrategies';
+import { utilities, type Types } from '@cornerstonejs/core';
+
+/**
+ * Creates and adds contour segmentations from a clipped surface.
+ *
+ * @param rawContourData - The raw contour data.
+ * @param viewport - The viewport.
+ * @param segmentationId - The segmentation ID.
+ */
+export function createAndAddContourSegmentationsFromClippedSurfaces(
+  rawContourData: RawContourData,
+  viewport: Types.IViewport,
+  segmentationId: string
+) {
+  const annotationUIDsMap = new Map<number, Set<string>>();
+
+  for (const [segmentIndex, contoursData] of rawContourData) {
+    for (const contourData of contoursData) {
+      const { points } = contourData;
+
+      const { lineSegments, linesNumberOfPoints } =
+        _extractLineSegments(contourData);
+
+      // There may be a few lines as the surface might not be closed and could have holes in it.
+      // Currently, we simply render the generated contour as empty fill to indicate
+      // the presence of holes. However, filling the proper area with
+      //  fillAlpha requires further work.
+      for (let i = 0; i < lineSegments.length; i++) {
+        const line = lineSegments[i];
+        const polyline = [];
+
+        for (let j = 0; j < linesNumberOfPoints[i]; j++) {
+          const pointIndex = line[j];
+          polyline.push([
+            points[3 * pointIndex],
+            points[3 * pointIndex + 1],
+            points[3 * pointIndex + 2],
+          ]);
+        }
+
+        if (polyline.length < 3) {
+          continue;
+        }
+
+        const contourSegmentationAnnotation = {
+          annotationUID: utilities.uuidv4(),
+          data: {
+            contour: {
+              closed: true,
+              polyline,
+            },
+            segmentation: {
+              segmentationId,
+              segmentIndex,
+            },
+            handles: {},
+          },
+          handles: {},
+          highlighted: false,
+          autoGenerated: false,
+          invalidated: false,
+          isLocked: false,
+          isVisible: true,
+          metadata: {
+            toolName: PlanarFreehandContourSegmentationTool.toolName,
+            ...viewport.getViewReference(),
+          },
+        };
+
+        addAnnotation(contourSegmentationAnnotation, viewport.element);
+
+        const currentSet = annotationUIDsMap.get(segmentIndex) || new Set();
+        currentSet.add(contourSegmentationAnnotation.annotationUID);
+        annotationUIDsMap.set(segmentIndex, currentSet);
+      }
+    }
+  }
+
+  return annotationUIDsMap;
+}
+
+const _extractLineSegments = (contourData) => {
+  const { numberOfCells, lines } = contourData;
+
+  const lineSegments = [];
+  const linesNumberOfPoints = [];
+
+  for (let i = 0; i < lines.length; ) {
+    const pointsInLine = lines[i];
+    linesNumberOfPoints.push(pointsInLine);
+    lineSegments.push(lines.slice(i + 1, i + pointsInLine + 1));
+    i += pointsInLine + 1;
+
+    if (lineSegments.length === numberOfCells) {
+      break;
+    }
+  }
+
+  return { lineSegments, linesNumberOfPoints };
+};

package/src/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.ts

@@ -0,0 +1,38 @@
+import { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { RawContourData } from '../contourComputationStrategies';
+
+/**
+ * Extracts contour data from the given polyDataCache.
+ * @param polyDataCache - The polyData cache containing intersection information.
+ * @param segmentIndexMap - Optional map for mapping surface IDs to segment indices.
+ * @returns A map of segment indices to an array of contour results.
+ */
+export function extractContourData(
+  polyDataCache: PolyDataClipCacheType,
+  segmentIndexMap?: Map<string, number>
+) {
+  const rawResults = new Map() as RawContourData;
+
+  for (const [cacheId, intersectionInfo] of polyDataCache) {
+    // Todo; fix this
+    const surfaceId = cacheId.split('_')[1];
+
+    for (const [_, result] of intersectionInfo) {
+      if (!result) {
+        continue;
+      }
+      const segmentIndex = Number(surfaceId) || segmentIndexMap?.get(surfaceId);
+
+      if (!segmentIndex) {
+        continue;
+      }
+
+      if (!rawResults.has(segmentIndex)) {
+        rawResults.set(segmentIndex, []);
+      }
+
+      rawResults.get(segmentIndex).push(result);
+    }
+  }
+  return rawResults;
+}

package/src/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.ts

@@ -0,0 +1,58 @@
+import { utilities, type Types, Enums } from '@cornerstonejs/core';
+import { extractContourData } from './extractContourData';
+import { clipAndCacheSurfacesForViewport } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './createAndAddContourSegmentationsFromClippedSurfaces';
+
+const currentViewportNormal = new Map();
+
+export function updateContoursOnCameraModified(
+  surfacesInfo,
+  viewport,
+  segmentationRepresentationUID
+) {
+  async function cameraModifiedCallback(
+    evt: Types.EventTypes.CameraModifiedEvent
+  ) {
+    const { camera } = evt.detail;
+    const { viewPlaneNormal } = camera;
+
+    // Note: I think choosing one of the surfaces to see
+    // if the viewPlaneNormal is the same for all surfaces is ok enough
+    // to decide if we should recompute the clipping planes
+    const surface1 = surfacesInfo[0];
+
+    const currentNormal = currentViewportNormal.get(surface1.id);
+    if (utilities.isEqual(viewPlaneNormal, currentNormal)) {
+      return;
+    }
+    currentViewportNormal.set(surface1.id, viewPlaneNormal);
+
+    const polyDataCache = await clipAndCacheSurfacesForViewport(
+      surfacesInfo,
+      viewport as Types.IVolumeViewport,
+      segmentationRepresentationUID
+    );
+
+    const results = extractContourData(polyDataCache);
+
+    createAndAddContourSegmentationsFromClippedSurfaces(
+      results,
+      viewport,
+      segmentationRepresentationUID
+    );
+
+    viewport.render();
+  }
+
+  const camera = viewport.getCamera();
+  currentViewportNormal.set(surfacesInfo[0].id, camera.viewPlaneNormal);
+
+  // Remove the existing event listener
+  viewport.element.removeEventListener(
+    Enums.Events.CAMERA_MODIFIED,
+    cameraModifiedCallback
+  );
+
+  // Add the event listener
+  viewport.element.addEventListener(Enums.Events.CAMERA_MODIFIED);
+}

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

@@ -91,7 +91,7 @@ export async function convertContourToVolumeLabelmap(
     }
   );
 
-  triggerWorkerProgress(eventTarget, 100);
+  triggerWorkerProgress(eventTarget, 1);
 
   segmentationVolume.imageData
     .getPointData()
@@ -227,7 +227,7 @@ export async function convertContourToStackLabelmap(
     }
   );
 
-  triggerWorkerProgress(eventTarget, 100);
+  triggerWorkerProgress(eventTarget, 1);
 
   const imageIdReferenceMap = new Map();
   newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {