@cornerstonejs/tools 1.52.0 → 1.54.0

package/src/utilities/segmentation/getSegmentAtLabelmapBorder.ts

@@ -0,0 +1,179 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import {
+  getSegmentation,
+  getSegmentationIdRepresentations,
+} from '../../stateManagement/segmentation/segmentationState';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+
+type Options = {
+  viewport?: Types.IViewport;
+  searchRadius?: number;
+};
+
+/**
+ * Retrieves the segment index at the border of a labelmap in a segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param worldPoint - The world coordinates of the point.
+ * @param options - Additional options.
+ * @param options.viewport - The viewport to use.
+ * @param options.searchRadius - The search radius to use.
+ * @returns The segment index at the labelmap border, or undefined if not found.
+ */
+export function getSegmentAtLabelmapBorder(
+  segmentationId: string,
+  worldPoint: Types.Point3,
+  { viewport, searchRadius }: Options
+): number {
+  const segmentation = getSegmentation(segmentationId);
+
+  const labelmapData = segmentation.representationData.LABELMAP;
+
+  if (isVolumeSegmentation(labelmapData)) {
+    const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+    const segmentationVolume = cache.getVolume(volumeId);
+
+    if (!segmentationVolume) {
+      return;
+    }
+
+    const imageData = segmentationVolume.imageData;
+
+    const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+
+    const canvasPoint = viewport.worldToCanvas(worldPoint);
+
+    const onEdge = isSegmentOnEdgeCanvas(
+      canvasPoint as Types.Point2,
+      segmentIndex,
+      viewport,
+      imageData,
+      searchRadius
+    );
+
+    return onEdge ? segmentIndex : undefined;
+  }
+
+  // stack segmentation case
+  const { imageIdReferenceMap } = labelmapData as LabelmapSegmentationDataStack;
+
+  const currentImageId = (viewport as Types.IStackViewport).getCurrentImageId();
+
+  const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+  const image = cache.getImage(segmentationImageId);
+
+  if (!image) {
+    return;
+  }
+
+  // find the first segmentationRepresentationUID for the segmentationId, since
+  // that is what we use as actorUID in the viewport
+
+  const segmentationRepresentations = getSegmentationIdRepresentations(
+    segmentation.segmentationId
+  );
+
+  const { segmentationRepresentationUID } = segmentationRepresentations[0];
+  const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+  const imageData = segmentationActor?.actor.getMapper().getInputData();
+  const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+
+  const dimensions = imageData.getDimensions();
+  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
+    dimensions,
+    imageData.getPointData().getScalars().getData()
+  );
+
+  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+
+  const onEdge = isSegmentOnEdgeIJK(
+    indexIJK as Types.Point3,
+    dimensions,
+    voxelManager,
+    segmentIndex
+  );
+
+  return onEdge ? segmentIndex : undefined;
+}
+
+/**
+ * Checks if a segment is on the edge of a labelmap.
+ * @param getNeighborIndex - A function that returns the neighbor index given the delta values.
+ * @param segmentIndex - The index of the segment to check.
+ * @param searchRadius - The radius within which to search for neighboring segments. Default is 1.
+ * @returns A boolean indicating whether the segment is on the edge.
+ */
+function isSegmentOnEdge(
+  getNeighborIndex: (
+    deltaI: number,
+    deltaJ: number,
+    deltaK: number
+  ) => number | undefined,
+  segmentIndex: number,
+  searchRadius = 1 // Default search radius
+): boolean {
+  const neighborRange = Array.from(
+    { length: 2 * searchRadius + 1 },
+    (_, i) => i - searchRadius
+  );
+
+  for (const deltaI of neighborRange) {
+    for (const deltaJ of neighborRange) {
+      for (const deltaK of neighborRange) {
+        if (deltaI === 0 && deltaJ === 0 && deltaK === 0) {
+          continue; // Skipping the central point
+        }
+
+        const neighborIndex = getNeighborIndex(deltaI, deltaJ, deltaK);
+
+        if (neighborIndex !== undefined && segmentIndex !== neighborIndex) {
+          return true; // On the edge
+        }
+      }
+    }
+  }
+
+  return false; // No edge neighbors found
+}
+
+function isSegmentOnEdgeIJK(
+  indexIJK: Types.Point3,
+  dimensions: Types.Point3,
+  voxelManager: any,
+  segmentIndex: number,
+  searchRadius?: number
+): boolean {
+  const getNeighborIndex = (deltaI: number, deltaJ: number, deltaK: number) => {
+    const neighborIJK = [
+      indexIJK[0] + deltaI,
+      indexIJK[1] + deltaJ,
+      indexIJK[2] + deltaK,
+    ];
+
+    return voxelManager.getAtIJK(...neighborIJK);
+  };
+
+  return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}
+
+function isSegmentOnEdgeCanvas(
+  canvasPoint: Types.Point2,
+  segmentIndex: number,
+  viewport: Types.IViewport,
+  imageData: any,
+  searchRadius?: number
+): boolean {
+  const getNeighborIndex = (deltaI: number, deltaJ: number) => {
+    const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
+
+    const worldPoint = viewport.canvasToWorld(neighborCanvas as Types.Point2);
+    return imageData.getScalarValueFromWorld(worldPoint);
+  };
+
+  return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}

package/src/utilities/segmentation/getSegmentAtWorldPoint.ts

@@ -0,0 +1,173 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import {
+  getSegmentation,
+  getSegmentationIdRepresentations,
+} from '../../stateManagement/segmentation/segmentationState';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import { ContourSegmentationAnnotation, Segmentation } from '../../types';
+import { getAnnotation } from '../../stateManagement';
+import { isPointInsidePolyline3D } from '../math/polyline';
+
+type Options = {
+  representationType?: SegmentationRepresentations;
+  viewport?: Types.IViewport;
+};
+
+/**
+ * Get the segment at the specified world point in the viewport.
+ * @param segmentationId - The ID of the segmentation to get the segment for.
+ * @param worldPoint - The world point to get the segment for.
+ *
+ * @returns The index of the segment at the world point, or undefined if not found.
+ */
+export function getSegmentAtWorldPoint(
+  segmentationId: string,
+  worldPoint: Types.Point3,
+  options = {} as Options
+): number {
+  const segmentation = getSegmentation(segmentationId);
+
+  const representationData = segmentation.representationData;
+
+  // if representationType is not provided, we will use the first representation
+  const desiredRepresentation =
+    options?.representationType ?? Object.keys(representationData)[0];
+
+  if (!desiredRepresentation) {
+    throw new Error(
+      `Segmentation ${segmentationId} does not have any representations`
+    );
+  }
+
+  switch (desiredRepresentation) {
+    case SegmentationRepresentations.Labelmap:
+      return getSegmentAtWorldForLabelmap(segmentation, worldPoint, options);
+    case SegmentationRepresentations.Contour:
+      return getSegmentAtWorldForContour(segmentation, worldPoint, options);
+    default:
+      return;
+  }
+}
+
+/**
+ * Retrieves the segment index at a given world point for a labelmap.
+ *
+ * @param labelmapData - The labelmap segmentation data.
+ * @param worldPoint - The world point to retrieve the segment at.
+ *
+ * @returns The segment index at the given world point, or undefined if not found.
+ */
+export function getSegmentAtWorldForLabelmap(
+  segmentation: Segmentation,
+  worldPoint: Types.Point3,
+  { viewport }: Options
+): number | undefined {
+  const labelmapData = segmentation.representationData.LABELMAP;
+
+  if (isVolumeSegmentation(labelmapData)) {
+    const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+    const segmentationVolume = cache.getVolume(volumeId);
+
+    if (!segmentationVolume) {
+      return;
+    }
+
+    const segmentIndex =
+      segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+
+    return segmentIndex;
+  }
+
+  // stack segmentation case
+  const { imageIdReferenceMap } = labelmapData as LabelmapSegmentationDataStack;
+
+  const currentImageId = (viewport as Types.IStackViewport).getCurrentImageId();
+
+  const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+  const image = cache.getImage(segmentationImageId);
+
+  if (!image) {
+    return;
+  }
+
+  // find the first segmentationRepresentationUID for the segmentationId, since
+  // that is what we use as actorUID in the viewport
+
+  const segmentationRepresentations = getSegmentationIdRepresentations(
+    segmentation.segmentationId
+  );
+
+  const { segmentationRepresentationUID } = segmentationRepresentations[0];
+
+  const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+  const imageData = segmentationActor?.actor.getMapper().getInputData();
+  const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+
+  const dimensions = imageData.getDimensions();
+  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
+    dimensions,
+    imageData.getPointData().getScalars().getData()
+  );
+
+  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+
+  return segmentIndex;
+}
+
+/**
+ * Retrieves the segment index at a given world point for contour segmentation.
+ *
+ * @param segmentation - The segmentation data.
+ * @param worldPoint - The world point to check.
+ * @param options - The options for segmentation.
+ * @returns The segment index at the given world point, or undefined if not found.
+ */
+export function getSegmentAtWorldForContour(
+  segmentation: Segmentation,
+  worldPoint: Types.Point3,
+  { viewport }: Options
+): number {
+  const contourData = segmentation.representationData.CONTOUR;
+
+  const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
+  const { viewPlaneNormal } = viewport.getCamera();
+
+  for (const segmentIndex of segmentIndices) {
+    const annotationsSet = contourData.annotationUIDsMap.get(segmentIndex);
+
+    if (!annotationsSet) {
+      continue;
+    }
+
+    for (const annotationUID of annotationsSet) {
+      const annotation = getAnnotation(
+        annotationUID
+      ) as ContourSegmentationAnnotation;
+
+      if (!annotation) {
+        continue;
+      }
+
+      const { polyline } = annotation.data.contour;
+
+      if (
+        !utilities.isEqual(viewPlaneNormal, annotation.metadata.viewPlaneNormal)
+      ) {
+        continue;
+      }
+
+      // This function checks whether we are inside the contour. It does not
+      // check if we are exactly on the contour, which is highly unlikely given
+      // the canvas pixel resolution of 1 decimal place we have by design.
+      if (isPointInsidePolyline3D(worldPoint, polyline)) {
+        return Number(segmentIndex);
+      }
+    }
+  }
+}

package/src/utilities/segmentation/getUniqueSegmentIndices.ts

@@ -0,0 +1,76 @@
+import { Types, cache } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+
+/**
+ * Retrieves the unique segment indices from a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @returns An array of unique segment indices.
+ * @throws If no geometryIds are found for the segmentationId.
+ */
+function getUniqueSegmentIndices(segmentationId) {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (segmentation.type === SegmentationRepresentations.Labelmap) {
+    const labelmapData =
+      segmentation.representationData[SegmentationRepresentations.Labelmap];
+
+    const keySet = new Set();
+
+    if (isVolumeSegmentation(labelmapData)) {
+      const volume = cache.getVolume(segmentationId);
+      const scalarData = volume.getScalarData();
+
+      for (let i = 0; i < scalarData.length; i++) {
+        const segmentIndex = scalarData[i];
+        if (segmentIndex !== 0) {
+          keySet.add(segmentIndex);
+        }
+      }
+    } else {
+      labelmapData.imageIdReferenceMap.forEach((segmentationImageId) => {
+        const image = cache.getImage(segmentationImageId);
+        const scalarData = image.getPixelData();
+
+        for (let i = 0; i < scalarData.length; i++) {
+          const segmentIndex = scalarData[i];
+          if (segmentIndex !== 0) {
+            keySet.add(segmentIndex);
+          }
+        }
+      });
+    }
+
+    return Array.from(keySet)
+      .map((it) => parseInt(it as string))
+      .sort();
+  } else if (segmentation.type === SegmentationRepresentations.Contour) {
+    const annotationUIDsMap =
+      segmentation.representationData.CONTOUR?.annotationUIDsMap;
+
+    const indices = new Set(annotationUIDsMap.keys());
+    const geometryIds = segmentation.representationData.CONTOUR?.geometryIds;
+
+    if (!geometryIds) {
+      throw new Error(
+        `No geometryIds found for segmentationId ${segmentationId}`
+      );
+    }
+
+    geometryIds.forEach((geometryId) => {
+      const geometry = cache.getGeometry(geometryId) as Types.IGeometry;
+      indices.add((geometry.data as Types.IContourSet).getSegmentIndex());
+    });
+
+    return Array.from(indices.values()).sort();
+  } else if (segmentation.type === SegmentationRepresentations.Surface) {
+    const geometryIds =
+      segmentation.representationData.SURFACE?.geometryIds ?? [];
+
+    return Array.from(geometryIds.keys());
+  }
+}
+
+export { getUniqueSegmentIndices };

package/src/utilities/segmentation/index.ts

@@ -20,6 +20,10 @@ import contourAndFindLargestBidirectional from './contourAndFindLargestBidirecti
 import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
 import { invalidateBrushCursor } from './invalidateBrushCursor';
+import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
+import { getSegmentAtWorldPoint } from './getSegmentAtWorldPoint';
+import { getSegmentAtLabelmapBorder } from './getSegmentAtLabelmapBorder';
+import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 
 export {
   thresholdVolumeByRange,
@@ -40,4 +44,8 @@ export {
   createBidirectionalToolData,
   segmentContourAction,
   invalidateBrushCursor,
+  getUniqueSegmentIndices,
+  getSegmentAtWorldPoint,
+  getSegmentAtLabelmapBorder,
+  getHoveredContourSegmentationAnnotation,
 };

package/src/utilities/triggerAnnotationRenderForToolGroupIds.ts

@@ -0,0 +1,38 @@
+import { getRenderingEngine, type Types } from '@cornerstonejs/core';
+import triggerAnnotationRender from './triggerAnnotationRender';
+import { getToolGroup } from '../store/ToolGroupManager';
+
+/**
+ * Triggers annotation rendering for the specified tool group IDs.
+ *
+ * @param toolGroupIds - An array of tool group IDs.
+ */
+export function triggerAnnotationRenderForToolGroupIds(
+  toolGroupIds: string[]
+): void {
+  toolGroupIds.forEach((toolGroupId) => {
+    const toolGroup = getToolGroup(toolGroupId);
+
+    if (!toolGroup) {
+      console.warn(`ToolGroup not available for ${toolGroupId}`);
+      return;
+    }
+
+    const viewportsInfo = toolGroup.getViewportsInfo();
+
+    viewportsInfo.forEach((viewportInfo) => {
+      const { renderingEngineId, viewportId } = viewportInfo;
+
+      const renderingEngine = getRenderingEngine(renderingEngineId);
+      if (!renderingEngine) {
+        console.warn(`RenderingEngine not available for ${renderingEngineId}`);
+        return;
+      }
+
+      const viewport = renderingEngine.getViewport(viewportId);
+      triggerAnnotationRender(viewport.element);
+    });
+  });
+}
+
+export default triggerAnnotationRenderForToolGroupIds;

package/src/workers/clippingPlaneWorker.js

@@ -0,0 +1,87 @@
+import { expose } from 'comlink';
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import vtkClipClosedSurface from '@kitware/vtk.js/Filters/General/ClipClosedSurface';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+
+const obj = {
+  /**
+   * Clips a 3D surface using provided planes and updates the cache and progress.
+   * The function takes in information about the planes and the polygon data, and applies a clipping filter.
+   * It then updates the cache and progress based on the processed data.
+   *
+   * @param clipInfo - Contains information about the planes and the polygon data.
+   * @param updateProgress - Callback function to update the progress of the clipping process.
+   * @param updateCache - Callback function to update the cache with the clipped data.
+   *
+   * @throws Will throw an error if the clipping process encounters an issue.
+   */
+  clipSurfaceWithPlanes(
+    { planesInfo, pointsAndPolys },
+    progressCallback,
+    updateCacheCallback
+  ) {
+    const numberOfPlanes = planesInfo.length;
+    const clippingFilter = vtkClipClosedSurface.newInstance({
+      clippingPlanes: [],
+      activePlaneId: 2,
+      passPointData: false,
+    });
+    clippingFilter.setGenerateOutline(true);
+    clippingFilter.setGenerateFaces(false);
+
+    const plane1 = vtkPlane.newInstance();
+    const plane2 = vtkPlane.newInstance();
+
+    try {
+      for (const [index, planeInfo] of planesInfo.entries()) {
+        const { sliceIndex, planes } = planeInfo;
+
+        const polyDataResults = new Map();
+        for (const polyDataInfo of pointsAndPolys) {
+          const { points, polys, id } = polyDataInfo;
+
+          const surfacePolyData = vtkPolyData.newInstance();
+          surfacePolyData.getPoints().setData(points, 3);
+          surfacePolyData.getPolys().setData(polys, 3);
+
+          clippingFilter.setInputData(surfacePolyData);
+
+          // Reusable array for clipping planes
+          const clippingPlanes = [plane1, plane2];
+
+          // Directly update plane instances
+          plane1.setOrigin(planes[0].origin);
+          plane1.setNormal(planes[0].normal);
+          plane2.setOrigin(planes[1].origin);
+          plane2.setNormal(planes[1].normal);
+
+          clippingFilter.setClippingPlanes(clippingPlanes);
+          clippingFilter.update();
+
+          const polyData = clippingFilter.getOutputData();
+
+          if (polyData) {
+            polyDataResults.set(id, {
+              points: polyData.getPoints().getData(),
+              lines: polyData.getLines().getData(),
+            });
+          }
+        }
+
+        progressCallback({ progress: (index + 1) / numberOfPlanes });
+
+        updateCacheCallback({ sliceIndex, polyDataResults });
+      }
+    } catch (e) {
+      console.error('Error during processing', e);
+    } finally {
+      // Cleanup on completion
+      pointsAndPolys = null;
+      clippingFilter.delete();
+      plane1.delete();
+      plane2.delete();
+    }
+  },
+};
+
+expose(obj);