@cornerstonejs/tools 1.57.1 → 1.58.0

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/annotation/SplineROITool.ts

@@ -692,29 +692,27 @@ class SplineROITool extends ContourSegmentationBaseTool {
     const spline = annotation.data.spline.instance;
 
     // Update current and all child annotations/splines
-    if (annotation.invalidated) {
-      const splineAnnotationsGroup = [
+    const splineAnnotationsGroup = [
+      annotation,
+      ...getChildAnnotations(annotation),
+    ].filter((annotation) =>
+      this._isSplineROIAnnotation(annotation)
+    ) as SplineROIAnnotation[];
+
+    splineAnnotationsGroup.forEach((annotation) => {
+      const spline = this._updateSplineInstance(element, annotation);
+      const splinePolylineCanvas = spline.getPolylinePoints();
+
+      this.updateContourPolyline(
         annotation,
-        ...getChildAnnotations(annotation),
-      ].filter((annotation) =>
-        this._isSplineROIAnnotation(annotation)
-      ) as SplineROIAnnotation[];
-
-      splineAnnotationsGroup.forEach((annotation) => {
-        const spline = this._updateSplineInstance(element, annotation);
-        const splinePolylineCanvas = spline.getPolylinePoints();
-
-        this.updateContourPolyline(
-          annotation,
-          {
-            points: splinePolylineCanvas,
-            closed: data.contour.closed,
-            targetWindingDirection: ContourWindingDirection.Clockwise,
-          },
-          viewport
-        );
-      });
-    }
+        {
+          points: splinePolylineCanvas,
+          closed: data.contour.closed,
+          targetWindingDirection: ContourWindingDirection.Clockwise,
+        },
+        viewport
+      );
+    });
 
     // Let the base class render the contour
     super.renderAnnotationInstance(renderContext);
@@ -1069,6 +1067,14 @@ class SplineROITool extends ContourSegmentationBaseTool {
     const splineConfig = this._getSplineConfig(splineType);
     const worldPoints = data.handles.points;
     const canvasPoints = worldPoints.map(worldToCanvas);
+    const resolution =
+      splineConfig.resolution !== undefined
+        ? parseInt(splineConfig.resolution)
+        : undefined;
+    const scale =
+      splineConfig.scale !== undefined
+        ? parseFloat(splineConfig.scale)
+        : undefined;
 
     spline.setControlPoints(canvasPoints);
     spline.closed = !!data.contour.closed;
@@ -1076,9 +1082,10 @@ class SplineROITool extends ContourSegmentationBaseTool {
     // Update spline resolution in case it has changed
     if (
       !spline.fixedResolution &&
-      spline.resolution !== splineConfig.resolution
+      resolution !== undefined &&
+      spline.resolution !== resolution
     ) {
-      spline.resolution = parseInt(splineConfig.resolution);
+      spline.resolution = resolution;
       annotation.invalidated = true;
     }
 
@@ -1086,10 +1093,10 @@ class SplineROITool extends ContourSegmentationBaseTool {
     if (
       spline instanceof CardinalSpline &&
       !spline.fixedScale &&
-      splineConfig.scale !== undefined &&
-      spline.scale !== splineConfig.scale
+      scale !== undefined &&
+      spline.scale !== scale
     ) {
-      spline.scale = splineConfig.scale;
+      spline.scale = scale;
       annotation.invalidated = true;
     }
 

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;