@cornerstonejs/tools 1.57.1 → 1.58.0

package/src/tools/displayTools/Surface/surfaceDisplay.ts

@@ -1,42 +1,18 @@
-import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import {
   cache,
   getEnabledElementByIds,
   Types,
-  Enums,
-  getWebWorkerManager,
-  eventTarget,
-  triggerEvent,
-  utilities,
   VolumeViewport3D,
 } from '@cornerstonejs/core';
 
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import Representations from '../../../enums/SegmentationRepresentations';
 import { getToolGroup } from '../../../store/ToolGroupManager';
-import {
-  SegmentationRepresentationConfig,
-  ToolGroupSpecificRepresentation,
-} from '../../../types/SegmentationStateTypes';
-import { registerDisplayToolsWorker } from '../registerDisplayToolsWorker';
+import { ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
 
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
 import { polySeg } from '../../../stateManagement/segmentation';
-import { pointToString } from '../../../utilities';
-import { WorkerTypes } from '../../../enums';
-const workerManager = getWebWorkerManager();
-
-const polyDataCache = new Map();
-const currentViewportNormal = new Map();
-
-const triggerWorkerProgress = (eventTarget, progress) => {
-  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-    progress,
-    type: WorkerTypes.DISPLAY_TOOL_CLIP_SURFACE,
-  });
-};
 
 /**
  * It removes a segmentation representation from the tool group's viewports and
@@ -82,16 +58,10 @@ function removeSegmentationRepresentation(
  */
 async function render(
   viewport: Types.IVolumeViewport,
-  representation: ToolGroupSpecificRepresentation,
-  toolGroupConfig: SegmentationRepresentationConfig
+  representation: ToolGroupSpecificRepresentation
 ): Promise<void> {
-  const {
-    colorLUTIndex,
-    active,
-    segmentationId,
-    segmentationRepresentationUID,
-    segmentsHidden,
-  } = representation;
+  const { colorLUTIndex, segmentationId, segmentationRepresentationUID } =
+    representation;
 
   const segmentation = SegmentationState.getSegmentation(segmentationId);
 
@@ -99,6 +69,12 @@ async function render(
     return;
   }
 
+  if (!(viewport instanceof VolumeViewport3D)) {
+    throw new Error(
+      'Surface rendering is only supported in 3D viewports, if you need to visualize the surface cuts in 2D viewports, you can use the Contour representation, see polySeg converters'
+    );
+  }
+
   let SurfaceData = segmentation.representationData[Representations.Surface];
 
   if (
@@ -134,18 +110,7 @@ async function render(
   const surfaces = [];
   geometryIds.forEach((geometryId, segmentIndex) => {
     const geometry = cache.getGeometry(geometryId);
-    if (!geometry) {
-      throw new Error(`No Surfaces found for geometryId ${geometryId}`);
-    }
-
-    if (geometry.type !== Enums.GeometryType.SURFACE) {
-      // Todo: later we can support converting other geometries to Surfaces
-      throw new Error(
-        `Geometry type ${geometry.type} not supported for rendering.`
-      );
-    }
-
-    if (!geometry.data) {
+    if (!geometry?.data) {
       console.warn(
         `No Surfaces found for geometryId ${geometryId}. Skipping render.`
       );
@@ -166,18 +131,6 @@ async function render(
     surfaces.push(surface);
   });
 
-  if (!(viewport instanceof VolumeViewport3D)) {
-    // const { viewPlaneNormal } = viewport.getCamera();
-    // currentViewportNormal.set(surface.id, structuredClone(viewPlaneNormal));
-    // if the viewport is not 3D means we should calculate
-    // the clipping planes for the surface and cache the results
-    generateAndCacheClippedSurfaces(
-      surfaces,
-      viewport,
-      segmentationRepresentationUID
-    );
-  }
-
   viewport.render();
 }
 
@@ -206,197 +159,9 @@ function _removeSurfaceFromToolGroupViewports(
   }
 }
 
-async function generateAndCacheClippedSurfaces(
-  surfaces: Types.ISurface[],
-  viewport: Types.IVolumeViewport | Types.IStackViewport,
-  segmentationRepresentationUID: string
-) {
-  registerDisplayToolsWorker();
-
-  // 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;
-  });
-
-  const pointsAndPolys = surfaces.map((surface) => {
-    const id = surface.id;
-    const points = surface.getPoints();
-    const polys = surface.getPolys();
-
-    return { id, points, polys };
-  });
-
-  const camera = viewport.getCamera();
-
-  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 = surfaces[0];
-
-    if (
-      utilities.isEqual(viewPlaneNormal, currentViewportNormal.get(surface1.id))
-    ) {
-      return;
-    }
-
-    currentViewportNormal.set(surface1.id, viewPlaneNormal);
-
-    workerManager.terminate('displayTools');
-
-    setTimeout(() => {
-      generateAndCacheClippedSurfaces(
-        surfaces,
-        viewport,
-        segmentationRepresentationUID
-      );
-    }, 0);
-
-    viewport.render();
-  }
-
-  // Remove the existing event listener
-  viewport.element.removeEventListener(
-    Enums.Events.CAMERA_MODIFIED,
-    cameraModifiedCallback as EventListener
-  );
-
-  // Add the event listener
-  viewport.element.addEventListener(
-    Enums.Events.CAMERA_MODIFIED,
-    cameraModifiedCallback as EventListener
-  );
-
-  triggerWorkerProgress(eventTarget, 0);
-
-  await workerManager
-    .executeTask(
-      'displayTools',
-      'clipSurfaceWithPlanes',
-      {
-        planesInfo,
-        pointsAndPolys,
-      },
-      {
-        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, 100);
-}
-
-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 get or create PolyData
-export function getOrCreatePolyData(actorEntry, cacheId, vtkPlanes) {
-  let actorCache = polyDataCache.get(actorEntry.uid);
-  if (!actorCache) {
-    actorCache = new Map();
-    polyDataCache.set(actorEntry.uid, actorCache);
-  }
-
-  let polyData = actorCache.get(cacheId);
-  if (!polyData) {
-    const clippingFilter = actorEntry.clippingFilter;
-    clippingFilter.setClippingPlanes(vtkPlanes);
-    try {
-      clippingFilter.update();
-      polyData = clippingFilter.getOutputData();
-      actorCache.set(cacheId, polyData);
-    } catch (e) {
-      console.error('Error clipping surface', e);
-    }
-  }
-  return polyData;
-}
-
-// Helper function to update PolyData cache
-export function updatePolyDataCache(actorUID, cacheId, polyDataResult) {
-  const { points, lines } = polyDataResult;
-  const polyData = vtkPolyData.newInstance();
-  polyData.getPoints().setData(points, 3);
-  const linesArray = vtkCellArray.newInstance({
-    values: Int16Array.from(lines),
-  });
-  polyData.setLines(linesArray);
-
-  let actorCache = polyDataCache.get(actorUID);
-  if (!actorCache) {
-    actorCache = new Map();
-    polyDataCache.set(actorUID, actorCache);
-  }
-  actorCache.set(cacheId, polyData);
-}
-
-// Helper function to get and sort planes info based on slice index
-export function getSortedPlanesInfo(viewport) {
-  const planesInfo = viewport.getSlicesClippingPlanes?.();
-  const currentSliceIndex = viewport.getSliceIndex();
-
-  // Sort 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;
-  });
-  return planesInfo;
-}
-
 export default {
   render,
   removeSegmentationRepresentation,
 };
 
-export { render, removeSegmentationRepresentation, polyDataCache };
+export { render, removeSegmentationRepresentation };

package/src/types/PolySeg.ts

@@ -3,5 +3,5 @@ import type { Types } from '@cornerstonejs/core';
 export type PolySegConversionOptions = {
   segmentIndices?: number[];
   segmentationRepresentationUID?: string;
-  viewport?: Types.IViewport;
+  viewport?: Types.IStackViewport | Types.IVolumeViewport;
 };

package/src/utilities/contourSegmentation/addContourSegmentationAnnotation.ts

@@ -16,6 +16,11 @@ export function addContourSegmentationAnnotation(
 
   const { segmentationId, segmentIndex } = annotation.data.segmentation;
   const segmentation = getSegmentation(segmentationId);
+
+  if (!segmentation.representationData.CONTOUR) {
+    segmentation.representationData.CONTOUR = { annotationUIDsMap: new Map() };
+  }
+
   const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
 
   let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
@@ -25,5 +30,8 @@ export function addContourSegmentationAnnotation(
     annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
   }
 
-  annotationsUIDsSet.add(annotation.annotationUID);
+  annotationUIDsMap.set(
+    segmentIndex,
+    annotationsUIDsSet.add(annotation.annotationUID)
+  );
 }

package/src/utilities/contourSegmentation/removeContourSegmentationAnnotation.ts

@@ -21,6 +21,10 @@ export function removeContourSegmentationAnnotation(
   const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
   const annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
 
+  if (!annotationsUIDsSet) {
+    return;
+  }
+
   annotationsUIDsSet.delete(annotation.annotationUID);
 
   // Delete segmentIndex Set if there is no more annotations

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

@@ -1,20 +1,74 @@
 import { Types } from '@cornerstonejs/core';
 
-export default function getAABB(polyline: Types.Point2[]): Types.AABB2 {
+/**
+ * Calculates the axis-aligned bounding box (AABB) of a polyline.
+ *
+ * @param polyline - The polyline represented as an array of points.
+ * @param options - Additional options for calculating the AABB.
+ * @param options.isWorld - Indicates whether the polyline represents points in 3D space (true) or 2D space (false).
+ *
+ * @returns The AABB of the polyline. If the polyline represents points in 3D space, returns an AABB3 object with properties minX, maxX, minY, maxY, minZ, and maxZ. If the polyline represents points in 2D space, returns an AABB2 object with properties minX, maxX, minY, and maxY.
+ */
+export default function getAABB(
+  polyline: Types.Point2[] | Types.Point3[] | number[],
+  options?: {
+    numDimensions: number;
+  }
+): Types.AABB2 | Types.AABB3 {
+  // need to check if the polyline is array of arrays or just
+  // a flat array of numbers
+  let polylineToUse = polyline;
+  const numDimensions = options?.numDimensions || 2;
+  const is3D = numDimensions === 3;
+
+  if (!Array.isArray(polyline[0])) {
+    const currentPolyline = polyline as number[];
+    // check the isWorld flag is provided or not which means every
+    // 3 elements in the array represent a point in 3D space
+    // otherwise, every 2 elements in the array represent a point in 2D space
+    const totalPoints = currentPolyline.length / numDimensions;
+
+    polylineToUse = new Array(currentPolyline.length / numDimensions) as
+      | Types.Point2[]
+      | Types.Point3[];
+
+    for (let i = 0, len = totalPoints; i < len; i++) {
+      polylineToUse[i] = [
+        currentPolyline[i * numDimensions],
+        currentPolyline[i * numDimensions + 1],
+      ];
+
+      if (is3D) {
+        polylineToUse[i].push(currentPolyline[i * numDimensions + 2]);
+      }
+    }
+  }
+
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
+  let minZ = Infinity;
+  let maxZ = -Infinity;
 
-  for (let i = 0, len = polyline.length; i < len; i++) {
-    const [x, y] = polyline[i];
+  polylineToUse = polylineToUse as Types.Point2[] | Types.Point3[];
+
+  for (let i = 0, len = polylineToUse.length; i < len; i++) {
+    const [x, y, z] = polylineToUse[i];
 
     // No Math.min/max calls for better performance
     minX = minX < x ? minX : x;
     minY = minY < y ? minY : y;
     maxX = maxX > x ? maxX : x;
     maxY = maxY > y ? maxY : y;
+
+    if (is3D) {
+      minZ = minZ < z ? minZ : z;
+      maxZ = maxZ > z ? maxZ : z;
+    }
   }
 
-  return { minX, maxX, minY, maxY };
+  return is3D
+    ? { minX, maxX, minY, maxY, minZ, maxZ } // AABB3
+    : { minX, maxX, minY, maxY }; // AABB2
 }

package/src/utilities/planar/index.ts

@@ -2,12 +2,14 @@ import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
 import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
 
 export default {
   filterAnnotationsWithinSlice,
   getWorldWidthAndHeightFromCorners,
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
+  isPlaneIntersectingAABB,
 };
 
 export {
@@ -15,4 +17,5 @@ export {
   getWorldWidthAndHeightFromCorners,
   filterAnnotationsForDisplay,
   getPointInLineOfSightWithCriteria,
+  isPlaneIntersectingAABB,
 };

package/src/utilities/planar/isPlaneIntersectingAABB.ts

@@ -0,0 +1,56 @@
+import { vec3 } from 'gl-matrix';
+
+/**
+ * Checks if a plane intersects with an Axis-Aligned Bounding Box (AABB).
+ *
+ * @param origin - The origin point of the plane.
+ * @param normal - The normal vector of the plane.
+ * @param minX - The minimum x-coordinate of the AABB.
+ * @param minY - The minimum y-coordinate of the AABB.
+ * @param minZ - The minimum z-coordinate of the AABB.
+ * @param maxX - The maximum x-coordinate of the AABB.
+ * @param maxY - The maximum y-coordinate of the AABB.
+ * @param maxZ - The maximum z-coordinate of the AABB.
+ * @returns A boolean indicating whether the plane intersects with the AABB.
+ */
+export const isPlaneIntersectingAABB = (
+  origin,
+  normal,
+  minX,
+  minY,
+  minZ,
+  maxX,
+  maxY,
+  maxZ
+) => {
+  const vertices = [
+    vec3.fromValues(minX, minY, minZ),
+    vec3.fromValues(maxX, minY, minZ),
+    vec3.fromValues(minX, maxY, minZ),
+    vec3.fromValues(maxX, maxY, minZ),
+    vec3.fromValues(minX, minY, maxZ),
+    vec3.fromValues(maxX, minY, maxZ),
+    vec3.fromValues(minX, maxY, maxZ),
+    vec3.fromValues(maxX, maxY, maxZ),
+  ];
+
+  const normalVec = vec3.fromValues(normal[0], normal[1], normal[2]);
+  const originVec = vec3.fromValues(origin[0], origin[1], origin[2]);
+
+  // Compute the distance from the plane to the origin using vec3.dot
+  const planeDistance = -vec3.dot(normalVec, originVec);
+
+  // Check if all vertices are on the same side of the plane
+  let initialSign = null;
+  for (const vertex of vertices) {
+    // Calculate distance using vec3.dot to simplify the equation
+    const distance = vec3.dot(normalVec, vertex) + planeDistance;
+    if (initialSign === null) {
+      initialSign = Math.sign(distance);
+    } else if (Math.sign(distance) !== initialSign) {
+      return true; // Found a vertex on the other side, so it intersects
+    }
+  }
+
+  return false;
+};