@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/tools/displayTools/Labelmap/labelmapDisplay.ts

@@ -23,9 +23,9 @@ import {
 } from '../../../types/SegmentationStateTypes';
 
 import addLabelmapToElement from './addLabelmapToElement';
-
 import removeLabelmapFromElement from './removeLabelmapFromElement';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
+import { polySeg } from '../../../stateManagement/segmentation';
 
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
@@ -40,6 +40,8 @@ function getRepresentationRenderingConfig() {
   };
 }
 
+let polySegConversionInProgress = false;
+
 /**
  * For each viewport, and for each segmentation, set the segmentation for the viewport's enabled element
  * Initializes the global and viewport specific state for the segmentation in the
@@ -136,11 +138,44 @@ async function render(
     return;
   }
 
-  const labelmapData =
-    segmentation.representationData[Representations.Labelmap];
+  let labelmapData = segmentation.representationData[Representations.Labelmap];
 
   let actorEntry = viewport.getActor(segmentationRepresentationUID);
-  if (isVolumeSegmentation(labelmapData)) {
+
+  if (
+    !actorEntry &&
+    polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID) &&
+    !polySegConversionInProgress
+  ) {
+    // meaning the requested segmentation representationUID does not have
+    // labelmap data, BUT we might be able to request a conversion from
+    // another representation to labelmap
+    // we need to check if we can request polySEG to convert the other
+    // underlying representations to Surface
+    polySegConversionInProgress = true;
+
+    labelmapData = await polySeg.computeAndAddLabelmapRepresentation(
+      segmentationId,
+      {
+        segmentationRepresentationUID,
+        viewport,
+      }
+    );
+
+    if (!labelmapData) {
+      throw new Error(
+        `No labelmap data found for segmentationId ${segmentationId}.`
+      );
+    }
+
+    polySegConversionInProgress = false;
+  }
+
+  if (!labelmapData) {
+    return;
+  }
+
+  if (isVolumeSegmentation(labelmapData, viewport)) {
     if (viewport instanceof StackViewport) {
       return;
     }

package/src/tools/displayTools/Labelmap/validateLabelmap.ts

@@ -0,0 +1,71 @@
+import { cache } from '@cornerstonejs/core';
+import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../types/LabelmapTypes';
+
+function validateRepresentationData(
+  segmentationRepresentationData: LabelmapSegmentationData
+): void {
+  if ('volumeId' in segmentationRepresentationData) {
+    segmentationRepresentationData =
+      segmentationRepresentationData as LabelmapSegmentationDataVolume;
+
+    const cachedVolume = cache.getVolume(
+      segmentationRepresentationData.volumeId
+    );
+
+    if (!cachedVolume) {
+      throw new Error(
+        `volumeId of ${segmentationRepresentationData.volumeId} not found in cache, you should load and cache volume before adding segmentation`
+      );
+    }
+  } else if ('imageIdReferenceMap' in segmentationRepresentationData) {
+    segmentationRepresentationData =
+      segmentationRepresentationData as LabelmapSegmentationDataStack;
+
+    if (!segmentationRepresentationData.imageIdReferenceMap) {
+      throw new Error(
+        'The segmentationInput.representationData.imageIdReferenceMap is undefined, please provide a valid representationData.imageIdReferenceMap'
+      );
+    }
+  } else {
+    throw new Error(
+      'The segmentationInput.representationData is undefined, please provide a valid representationData'
+    );
+  }
+}
+
+/**
+ * Validates the public segmentation input.
+ * Throws an error if the segmentation input is invalid.
+ *
+ * @param segmentationInput - The segmentation input to validate.
+ */
+export function validatePublic(
+  segmentationInput: SegmentationPublicInput
+): void {
+  if (!segmentationInput.representation.data) {
+    throw new Error(
+      'The segmentationInput.representationData.data is undefined, please provide a valid representationData.data'
+    );
+  }
+
+  const representationData = segmentationInput.representation
+    .data as LabelmapSegmentationData;
+
+  validateRepresentationData(representationData);
+}
+
+/**
+ * Validates the given segmentation representation data.
+ *
+ * @param segmentationRepresentationData The segmentation representation data to validate.
+ */
+export function validate(
+  segmentationRepresentationData: LabelmapSegmentationData
+) {
+  validateRepresentationData(segmentationRepresentationData);
+}

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

@@ -0,0 +1,172 @@
+import {
+  getEnabledElement,
+  Enums,
+  VolumeViewport3D,
+} from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkClipClosedSurface from '@kitware/vtk.js/Filters/General/ClipClosedSurface';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import {
+  generateCacheId,
+  getOrCreatePolyData,
+  getSurfaceActorUID,
+} from './surfaceDisplay';
+
+function addOrUpdateSurfaceToElement(
+  element: HTMLDivElement,
+  surface: Types.ISurface,
+  segmentationRepresentationUID: string
+): void {
+  const actorUID = getSurfaceActorUID(
+    segmentationRepresentationUID,
+    surface.id
+  );
+
+  const enabledElement = getEnabledElement(element);
+  const { viewport } = enabledElement;
+  const surfaceActor = viewport.getActor(actorUID)?.actor as Types.Actor;
+
+  if (surfaceActor) {
+    // we already have an actor for this surface, we just need to update it
+
+    // Todo: figure out if the surface configuration has changed
+
+    const surfaceMapper = surfaceActor.getMapper();
+    const currentPolyData = surfaceMapper.getInputData();
+
+    // check if the new data is the same as the old data by checking the
+    // length of the points and the length of the polys
+
+    const newPoints = surface.getPoints();
+    const newPolys = surface.getPolys();
+
+    const currentPoints = currentPolyData.getPoints().getData();
+    const currentPolys = currentPolyData.getPolys().getData();
+
+    if (
+      newPoints.length === currentPoints.length &&
+      newPolys.length === currentPolys.length
+    ) {
+      // the data is the same, we don't need to update the actor
+
+      return;
+    }
+
+    const polyData = vtkPolyData.newInstance();
+    polyData.getPoints().setData(newPoints, 3);
+
+    const triangles = vtkCellArray.newInstance({
+      values: Float32Array.from(newPolys),
+    });
+
+    polyData.setPolys(triangles);
+
+    surfaceMapper.setInputData(polyData);
+    surfaceMapper.modified();
+
+    setTimeout(() => {
+      viewport.getRenderer().resetCameraClippingRange();
+    }, 0);
+
+    return;
+  }
+
+  // Default to true since we are setting a new segmentation, however,
+  // in the event listener, we will make other segmentations visible/invisible
+  // based on the config
+  const points = surface.getPoints();
+  const polys = surface.getPolys();
+  const color = surface.getColor();
+
+  const surfacePolyData = vtkPolyData.newInstance();
+  surfacePolyData.getPoints().setData(points, 3);
+
+  const triangles = vtkCellArray.newInstance({
+    values: Float32Array.from(polys),
+  });
+  surfacePolyData.setPolys(triangles);
+
+  const mapper = vtkMapper.newInstance({});
+
+  let clippingFilter;
+  if (!(viewport instanceof VolumeViewport3D)) {
+    clippingFilter = vtkClipClosedSurface.newInstance({
+      clippingPlanes: [],
+      activePlaneId: 2,
+      passPointData: false,
+    });
+    clippingFilter.setInputData(surfacePolyData);
+    clippingFilter.setGenerateOutline(true);
+    clippingFilter.setGenerateFaces(false);
+    clippingFilter.update();
+    const filteredData = clippingFilter.getOutputData();
+    mapper.setInputData(filteredData);
+
+    const evt = {
+      detail: {
+        actorEntry: {
+          actor: {
+            getMapper: () => mapper,
+          },
+          clippingFilter,
+          uid: actorUID,
+        },
+        // @ts-ignore
+        vtkPlanes: viewport.getClippingPlanesForActor?.(),
+        viewport,
+      },
+    };
+
+    updateSurfacePlanes(evt);
+
+    element.addEventListener(
+      Enums.Events.CLIPPING_PLANES_UPDATED,
+      updateSurfacePlanes
+    );
+  } else {
+    mapper.setInputData(surfacePolyData);
+  }
+
+  const actor = vtkActor.newInstance();
+  actor.setMapper(mapper);
+
+  // sets the color of the surface actor
+  actor.getProperty().setColor(color[0] / 255, color[1] / 255, color[2] / 255);
+
+  // set line width
+  // Todo: make this configurable
+  actor.getProperty().setLineWidth(2);
+
+  viewport.addActor({
+    actor,
+    uid: actorUID,
+    clippingFilter,
+  });
+
+  viewport.resetCamera();
+
+  setTimeout(() => {
+    viewport.getRenderer().resetCameraClippingRange();
+  }, 0);
+}
+
+/**
+ * Updates the clipping planes of a surface and caches the resulting poly data
+ */
+function updateSurfacePlanes(evt) {
+  const { actorEntry, vtkPlanes, viewport } = evt.detail;
+  if (!actorEntry?.clippingFilter) {
+    return;
+  }
+  const sliceIndex = viewport.getSliceIndex();
+  const mapper = actorEntry.actor.getMapper();
+  const { viewPlaneNormal } = viewport.getCamera();
+  const cacheId = generateCacheId(viewport, viewPlaneNormal, sliceIndex);
+  const polyData = getOrCreatePolyData(actorEntry, cacheId, vtkPlanes);
+  mapper.setInputData(polyData);
+}
+
+export default addOrUpdateSurfaceToElement;

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

@@ -0,0 +1,12 @@
+import { SurfaceRenderingConfig } from '../../../types/SurfaceTypes';
+
+const defaultSurfaceConfig: SurfaceRenderingConfig = {
+  renderFill: true,
+  fillAlpha: 1,
+};
+
+function getDefaultSurfaceConfig(): SurfaceRenderingConfig {
+  return defaultSurfaceConfig;
+}
+
+export default getDefaultSurfaceConfig;

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

@@ -1,8 +1,15 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import {
   cache,
   getEnabledElementByIds,
   Types,
   Enums,
+  VolumeViewport,
+  getWebWorkerManager,
+  eventTarget,
+  triggerEvent,
+  utilities,
 } from '@cornerstonejs/core';
 
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
@@ -12,9 +19,24 @@ import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
+import { registerDisplayToolsWorker } from '../registerDisplayToolsWorker';
 
 import removeSurfaceFromElement from './removeSurfaceFromElement';
-import addSurfaceToElement from './addSurfaceToElement';
+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
@@ -72,56 +94,91 @@ async function render(
   } = representation;
 
   const segmentation = SegmentationState.getSegmentation(segmentationId);
-  const SurfaceData = segmentation.representationData[Representations.Surface];
-  const { geometryId } = SurfaceData;
 
-  if (!geometryId) {
-    console.warn(
-      `No Surfaces found for segmentationId ${segmentationId}. Skipping render.`
-    );
+  if (!segmentation) {
+    return;
   }
 
-  const geometry = cache.getGeometry(geometryId);
-  if (!geometry) {
-    throw new Error(`No Surfaces found for geometryId ${geometryId}`);
-  }
+  let SurfaceData = segmentation.representationData[Representations.Surface];
 
-  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 (
+    !SurfaceData &&
+    polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID)
+  ) {
+    // we need to check if we can request polySEG to convert the other
+    // underlying representations to Surface
+    SurfaceData = await polySeg.computeAndAddSurfaceRepresentation(
+      segmentationId,
+      {
+        segmentationRepresentationUID,
+      }
     );
+
+    if (!SurfaceData) {
+      throw new Error(
+        `No Surface data found for segmentationId ${segmentationId}.`
+      );
+    }
   }
 
-  if (!geometry.data) {
+  const { geometryIds } = SurfaceData;
+
+  if (!geometryIds?.size) {
     console.warn(
-      `No Surfaces found for geometryId ${geometryId}. Skipping render.`
+      `No Surfaces found for segmentationId ${segmentationId}. Skipping render.`
     );
-    return;
   }
 
-  const surface = geometry.data;
+  const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
 
-  const surfaceUID = `${segmentationRepresentationUID}_${surface.id}}`;
-  _renderSurface(viewport, surface, surfaceUID);
+  const surfaces = [];
+  geometryIds.forEach((geometryId, segmentIndex) => {
+    const geometry = cache.getGeometry(geometryId);
+    if (!geometry) {
+      throw new Error(`No Surfaces found for geometryId ${geometryId}`);
+    }
 
-  viewport.resetCamera();
-  viewport.render();
-}
+    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.`
+      );
+    }
 
-function _renderSurface(
-  viewport: Types.IVolumeViewport,
-  surface: any,
-  surfaceUID: string
-): void {
-  const actorUID = surfaceUID;
-  const actorEntry = viewport.getActor(actorUID);
+    if (!geometry.data) {
+      console.warn(
+        `No Surfaces found for geometryId ${geometryId}. Skipping render.`
+      );
+      return;
+    }
 
-  if (!actorEntry) {
-    addSurfaceToElement(viewport.element, surface, actorUID);
-  } else {
-    throw new Error('Not implemented yet. (Update surface)');
+    const surface = geometry.data as Types.ISurface;
+
+    const color = colorLUT[segmentIndex];
+    surface.setColor(color.slice(0, 3) as Types.Point3);
+
+    addOrUpdateSurfaceToElement(
+      viewport.element,
+      surface as Types.ISurface,
+      segmentationRepresentationUID
+    );
+
+    surfaces.push(surface);
+  });
+
+  if (viewport instanceof VolumeViewport) {
+    // 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();
 }
 
 function _removeSurfaceFromToolGroupViewports(
@@ -149,7 +206,190 @@ function _removeSurfaceFromToolGroupViewports(
   }
 }
 
+async function generateAndCacheClippedSurfaces(
+  surfaces: Types.ISurface[],
+  viewport: Types.IVolumeViewport,
+  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?.();
+
+  // @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 };