@cornerstonejs/tools 1.57.2 → 1.58.1

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

@@ -70,7 +70,7 @@ export async function convertSurfaceToVolumeLabelmap(
     }
   );
 
-  triggerWorkerProgress(eventTarget, 100);
+  triggerWorkerProgress(eventTarget, 1);
 
   segmentationVolume.imageData
     .getPointData()

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

@@ -1,9 +1,5 @@
-import {
-  Types,
-  VolumeViewport,
-  volumeLoader,
-  utilities,
-} from '@cornerstonejs/core';
+import { VolumeViewport, volumeLoader, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
 import { getSegmentation } from '../../segmentationState';
 import {
@@ -16,7 +12,6 @@ import {
 } from './convertContourToLabelmap';
 import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
 import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
-import { PixelDataTypedArray } from '@cornerstonejs/core/dist/types/types';
 import { PolySegConversionOptions } from '../../../../types';
 
 export type RawLabelmapData =
@@ -166,7 +161,7 @@ async function computeLabelmapFromSurfaceSegmentation(
     segmentationVolume = await volumeLoader.createLocalSegmentationVolume(
       {
         ...volumeProps,
-        scalarData: volumeProps.scalarData as PixelDataTypedArray,
+        scalarData: volumeProps.scalarData as Types.PixelDataTypedArray,
         referencedImageIds: imageIds,
       },
       volumeId

package/src/stateManagement/segmentation/polySeg/Surface/convertContourToSurface.ts

@@ -56,7 +56,7 @@ export async function convertContourToSurface(
     }
   );
 
-  triggerWorkerProgress(eventTarget, 100);
+  triggerWorkerProgress(eventTarget, 1);
 
   return results;
 }

package/src/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.ts

@@ -75,7 +75,7 @@ export async function convertLabelmapToSurface(
     }
   );
 
-  triggerWorkerProgress(eventTarget, 100);
+  triggerWorkerProgress(eventTarget, 1);
 
   return results;
 }

package/src/stateManagement/segmentation/polySeg/computeAndAddRepresentation.ts

@@ -36,7 +36,7 @@ async function computeAndAddRepresentation<T>(
   addRepresentationData({
     segmentationId,
     type: representationType,
-    data: { ...data },
+    data,
   });
 
   // Update internal structures and possibly UI components

package/src/stateManagement/segmentation/triggerSegmentationEvents.ts

@@ -12,6 +12,7 @@ import {
   SegmentationRepresentationRemovedEventDetail,
   SegmentationRemovedEventDetail,
 } from '../../types/EventTypes';
+import { setSegmentationDirty } from '../../utilities/segmentation/getUniqueSegmentIndices';
 
 /**
  * Trigger an event that a segmentation is removed
@@ -143,6 +144,10 @@ function triggerSegmentationDataModified(
     modifiedSlicesToUse,
   };
 
+  // set it to dirty to force the next call to getUniqueSegmentIndices to
+  // recalculate the segment indices
+  setSegmentationDirty(segmentationId);
+
   triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
 }
 

package/src/store/ToolGroupManager/getToolGroupForViewport.ts

@@ -1,3 +1,4 @@
+import { getRenderingEngines } from '@cornerstonejs/core';
 import { state } from '../index';
 import { IToolGroup } from '../../types';
 
@@ -17,8 +18,14 @@ import { IToolGroup } from '../../types';
  */
 function getToolGroupForViewport(
   viewportId: string,
-  renderingEngineId: string
+  renderingEngineId?: string
 ): IToolGroup | undefined {
+  if (!renderingEngineId) {
+    renderingEngineId = getRenderingEngines().find((re) =>
+      re.getViewports().find((vp) => vp.id === viewportId)
+    )?.id;
+  }
+
   const toolGroupFilteredByIds = state.toolGroups.filter((tg) =>
     tg.viewportsInfo.some(
       (vp) =>

package/src/tools/base/BaseTool.ts

@@ -104,6 +104,13 @@ abstract class BaseTool implements IBaseTool {
     callbackType: StrategyCallbacks | string
   ): any {
     const { strategies, activeStrategy } = this.configuration;
+
+    if (!strategies[activeStrategy]) {
+      throw new Error(
+        `applyActiveStrategyCallback: active strategy ${activeStrategy} not found, check tool configuration or spellings`
+      );
+    }
+
     return strategies[activeStrategy][callbackType]?.call(
       this,
       enabledElement,

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -196,6 +196,11 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
     const annotationLocked = segmentsLocked.includes(segmentIndex as never);
 
+    // Todo: we should really get styles every time we render, since it is getting
+    // the style for the visibility and that goes through the segment indices
+    // calculation which is expensive. We should cache the styles and only update
+    // them if the segmentation representation modified event is triggered.
+
     const segmentColor = segmentationConfig.color.getColorForSegmentIndex(
       toolGroupId,
       segmentationRepresentationUID,

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -1,7 +1,6 @@
 import {
   getEnabledElementByIds,
   Types,
-  StackViewport,
   BaseVolumeViewport,
 } from '@cornerstonejs/core';
 
@@ -15,6 +14,9 @@ import {
 import { addOrUpdateVTKContourSets } from './vtkContour/addOrUpdateVTKContourSets';
 import removeContourFromElement from './removeContourFromElement';
 import { deleteConfigCache } from './vtkContour/contourConfigCache';
+import { polySeg } from '../../../stateManagement/segmentation';
+
+let polySegConversionInProgress = false;
 
 /**
  * It removes a segmentation representation from the tool group's viewports and
@@ -72,19 +74,35 @@ async function render(
     return;
   }
 
-  const contourData = segmentation.representationData[Representations.Contour];
-
-  const { geometryIds, annotationUIDsMap } = contourData;
-
-  if (!geometryIds?.length && !annotationUIDsMap?.size) {
-    return;
+  let contourData = segmentation.representationData[Representations.Contour];
+
+  if (
+    !contourData &&
+    polySeg.canComputeRequestedRepresentation(
+      representationConfig.segmentationRepresentationUID
+    ) &&
+    !polySegConversionInProgress
+  ) {
+    polySegConversionInProgress = true;
+
+    contourData = await polySeg.computeAndAddContourRepresentation(
+      segmentationId,
+      {
+        segmentationRepresentationUID:
+          representationConfig.segmentationRepresentationUID,
+        viewport,
+      }
+    );
   }
 
-  // this means we would like to use vtk actors for contour data
+  // From here to below it is basically the legacy geometryId based
+  // contour rendering via vtkActors that has some bugs for display,
+  // as it sometimes appear and sometimes not, and it is not clear.
+  // We have moved to the new SVG based contours via our annotation tools
+  // check out annotationUIDsMap in the ContourSegmentationData type
+  const { geometryIds } = contourData;
 
-  if (!(viewport instanceof BaseVolumeViewport)) {
-    // We don't have a good way to handle stack viewports for contours at the moment.
-    // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
+  if (!geometryIds?.length || !(viewport instanceof BaseVolumeViewport)) {
     return;
   }
 

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

@@ -143,7 +143,7 @@ async function render(
   let actorEntry = viewport.getActor(segmentationRepresentationUID);
 
   if (
-    !actorEntry &&
+    !labelmapData &&
     polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID) &&
     !polySegConversionInProgress
   ) {

package/src/tools/displayTools/SegmentationDisplayTool.ts

@@ -18,7 +18,11 @@ import {
 import { surfaceDisplay } from './Surface';
 import { contourDisplay } from './Contour';
 import { labelmapDisplay } from './Labelmap';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { addTool, state } from '../../store';
+import PlanarFreehandContourSegmentationTool from '../annotation/PlanarFreehandContourSegmentationTool';
 
+const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
 /**
  * In Cornerstone3DTools, displaying of segmentations are handled by the SegmentationDisplayTool.
  * Generally, any Segmentation can be viewed in various representations such as
@@ -151,6 +155,12 @@ class SegmentationDisplayTool extends BaseTool {
           [Representations.Surface]: surfaceDisplay,
         };
 
+        if (representation.type === SegmentationRepresentations.Contour) {
+          // if the representation is contour we need to make sure
+          // that the planarFreeHandTool is added to the toolGroup
+          this.addPlanarFreeHandToolIfAbsent(toolGroupId);
+        }
+
         const display = renderers[representation.type];
 
         for (const viewport of toolGroupViewports) {
@@ -174,6 +184,22 @@ class SegmentationDisplayTool extends BaseTool {
     });
   };
 
+  addPlanarFreeHandToolIfAbsent(toolGroupId) {
+    // if it is contour we should check if the toolGroup and more importantly
+    // the cornerstoneTools have the planarFreeHandTool added
+    if (!(planarContourToolName in state.tools)) {
+      addTool(PlanarFreehandContourSegmentationTool);
+    }
+
+    const toolGroup = getToolGroup(toolGroupId);
+
+    // check if toolGroup has this tool
+    if (!toolGroup.hasTool(planarContourToolName)) {
+      toolGroup.addTool(planarContourToolName);
+      toolGroup.setToolPassive(planarContourToolName);
+    }
+  }
+
   /**
    * Merge the toolGroup specific configuration with the default global configuration
    * @param toolGroupId

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

@@ -1,19 +1,10 @@
-import {
-  getEnabledElement,
-  Enums,
-  VolumeViewport3D,
-} from '@cornerstonejs/core';
+import { getEnabledElement } 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';
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport';
 
 function addOrUpdateSurfaceToElement(
   element: HTMLDivElement,
@@ -92,44 +83,7 @@ function addOrUpdateSurfaceToElement(
   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);
-
-    // @ts-ignore
-    const viewportPlanes = viewport.getClippingPlanesForActor?.();
-
-    const evt = {
-      detail: {
-        actorEntry: {
-          actor: {
-            getMapper: () => mapper,
-          },
-          clippingFilter,
-          uid: actorUID,
-        },
-        vtkPlanes: viewportPlanes,
-      },
-    };
-
-    updateSurfacePlanes(evt);
-
-    element.addEventListener(
-      Enums.Events.CLIPPING_PLANES_UPDATED,
-      updateSurfacePlanes
-    );
-  } else {
-    mapper.setInputData(surfacePolyData);
-  }
+  mapper.setInputData(surfacePolyData);
 
   const actor = vtkActor.newInstance();
   actor.setMapper(mapper);
@@ -155,20 +109,4 @@ function addOrUpdateSurfaceToElement(
   }, 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 || vtkPlanes.length === 0) {
-    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/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;
 };