@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.11

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

@@ -4,102 +4,44 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import {
   cache,
   getEnabledElementByIds,
+  StackViewport,
   Types,
-  utilities,
+  VolumeViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { getToolGroup } from '../../../store/ToolGroupManager';
 import type {
   LabelmapConfig,
   LabelmapRenderingConfig,
+  LabelmapSegmentationData,
 } from '../../../types/LabelmapTypes';
 import {
-  RepresentationPublicInput,
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } 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();
 
-/**
- * For each viewport, in the toolGroup it adds the segmentation labelmap
- * representation to its viewports.
- * @param toolGroup - the tool group that contains the viewports
- * @param representationInput - The segmentation representation input
- * @param toolGroupSpecificConfig - The configuration object for toolGroup
- *
- * @returns The UID of the new segmentation representation
- */
-async function addSegmentationRepresentation(
-  toolGroupId: string,
-  representationInput: RepresentationPublicInput,
-  toolGroupSpecificConfig?: SegmentationRepresentationConfig
-): Promise<string> {
-  const { segmentationId } = representationInput;
-  const segmentationRepresentationUID = utilities.uuidv4();
-
-  // Todo: make these configurable during representation input by user
-  const segmentsHidden = new Set() as Set<number>;
-  const colorLUTIndex = 0;
-  const active = true;
+function getRepresentationRenderingConfig() {
   const cfun = vtkColorTransferFunction.newInstance();
   const ofun = vtkPiecewiseFunction.newInstance();
-
   ofun.addPoint(0, 0);
-
-  const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
-    segmentationId,
-    segmentationRepresentationUID,
-    type: Representations.Labelmap,
-    segmentsHidden,
-    colorLUTIndex,
-    active,
-    segmentationRepresentationSpecificConfig: {},
-    segmentSpecificConfig: {},
-    config: {
-      cfun,
-      ofun,
-    },
+  return {
+    ofun,
+    cfun,
   };
-
-  // Update the toolGroup specific configuration
-  if (toolGroupSpecificConfig) {
-    // Since setting configuration on toolGroup will trigger a segmentationRepresentation
-    // update event, we don't want to trigger the event twice, so we suppress
-    // the first one
-    const currentToolGroupConfig =
-      SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-
-    const mergedConfig = utilities.deepMerge(
-      currentToolGroupConfig,
-      toolGroupSpecificConfig
-    );
-
-    SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
-      renderInactiveSegmentations:
-        mergedConfig.renderInactiveSegmentations || true,
-      representations: {
-        ...mergedConfig.representations,
-      },
-    });
-  }
-
-  SegmentationState.addSegmentationRepresentation(
-    toolGroupId,
-    toolGroupSpecificRepresentation
-  );
-
-  return segmentationRepresentationUID;
 }
 
+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
@@ -176,7 +118,7 @@ function isSameFrameOfReference(viewport, referencedVolumeId) {
  * @param configuration - The configuration object for the labelmap.
  */
 async function render(
-  viewport: Types.IVolumeViewport,
+  viewport: Types.IVolumeViewport | Types.IStackViewport,
   representation: ToolGroupSpecificRepresentation,
   toolGroupConfig: SegmentationRepresentationConfig
 ): Promise<void> {
@@ -190,31 +132,99 @@ async function render(
   } = representation;
 
   const segmentation = SegmentationState.getSegmentation(segmentationId);
-  const labelmapData =
-    segmentation.representationData[Representations.Labelmap];
-  const { volumeId: labelmapUID } = labelmapData;
 
-  const labelmap = cache.getVolume(labelmapUID);
+  if (!segmentation) {
+    console.warn('No segmentation found for segmentationId: ', segmentationId);
+    return;
+  }
+
+  let labelmapData = segmentation.representationData[Representations.Labelmap];
 
-  if (!labelmap) {
-    throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
+  let actorEntry = viewport.getActor(segmentationRepresentationUID);
+
+  if (
+    !labelmapData &&
+    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 (!isSameFrameOfReference(viewport, labelmapData?.referencedVolumeId)) {
+  if (!labelmapData) {
     return;
   }
-  let actorEntry = viewport.getActor(segmentationRepresentationUID);
 
-  if (!actorEntry) {
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
-    const { volumeId } =
-      segmentation.representationData[Representations.Labelmap];
-    // only add the labelmap to ToolGroup viewports if it is not already added
-    await _addLabelmapToViewport(
-      viewport,
-      volumeId,
-      segmentationRepresentationUID
-    );
+  if (isVolumeSegmentation(labelmapData, viewport)) {
+    if (viewport instanceof StackViewport) {
+      return;
+    }
+
+    const { volumeId: labelmapUID } = labelmapData;
+
+    const labelmap = cache.getVolume(labelmapUID);
+
+    if (!labelmap) {
+      throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
+    }
+
+    if (!isSameFrameOfReference(viewport, labelmapData?.referencedVolumeId)) {
+      return;
+    }
+
+    if (!actorEntry) {
+      // only add the labelmap to ToolGroup viewports if it is not already added
+      await _addLabelmapToViewport(
+        viewport,
+        labelmapData,
+        segmentationRepresentationUID
+      );
+    }
+
+    actorEntry = viewport.getActor(segmentationRepresentationUID);
+  } else {
+    if (viewport instanceof VolumeViewport) {
+      return;
+    }
+
+    // stack segmentation
+    const imageId = viewport.getCurrentImageId();
+    const { imageIdReferenceMap } = labelmapData;
+
+    // if the stack labelmap is not built for the current imageId that is
+    // rendered at the viewport then return
+    if (!imageIdReferenceMap.has(imageId)) {
+      return;
+    }
+
+    if (!actorEntry) {
+      // only add the labelmap to ToolGroup viewports if it is not already added
+      await _addLabelmapToViewport(
+        viewport,
+        labelmapData,
+        segmentationRepresentationUID
+      );
+    }
 
     actorEntry = viewport.getActor(segmentationRepresentationUID);
   }
@@ -264,7 +274,6 @@ function _setLabelmapColorAndOpacity(
   // the default color table uses RGB.
   const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
   const numColors = Math.min(256, colorLUT.length);
-  const volumeActor = actorEntry.actor as Types.VolumeActor;
   const { uid: actorUID } = actorEntry;
 
   // Note: right now outlineWidth and renderOutline are not configurable
@@ -276,6 +285,9 @@ function _setLabelmapColorAndOpacity(
     isActiveLabelmap
   );
 
+  // Todo: the below loop probably can be optimized so that we don't hit it
+  // unless a config has changed. Right now we get into the following loop
+  // even for brush drawing which does not makes sense
   for (let i = 0; i < numColors; i++) {
     const segmentIndex = i;
     const segmentColor = colorLUT[segmentIndex];
@@ -324,24 +336,51 @@ function _setLabelmapColorAndOpacity(
     }
   }
 
-  volumeActor.getProperty().setRGBTransferFunction(0, cfun);
+  const actor = actorEntry.actor as Types.VolumeActor;
+
+  actor.getProperty().setRGBTransferFunction(0, cfun);
 
   ofun.setClamping(false);
-  volumeActor.getProperty().setScalarOpacity(0, ofun);
 
-  volumeActor.getProperty().setInterpolationTypeToNearest();
+  actor.getProperty().setScalarOpacity(0, ofun);
+  actor.getProperty().setInterpolationTypeToNearest();
+  actor.getProperty().setUseLabelOutline(renderOutline);
+
+  // @ts-ignore - fix type in vtk
+  actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+
+  const { activeSegmentIndex } = SegmentationState.getSegmentation(
+    segmentationRepresentation.segmentationId
+  );
+
+  // create an array that contains all the segment indices and for the active
+  // segment index, use the activeSegmentOutlineWidthDelta, otherwise use the
+  // outlineWidth
+  // Pre-allocate the array with the required size to avoid dynamic resizing.
+  const outlineWidths = new Array(numColors - 1);
 
-  volumeActor.getProperty().setUseLabelOutline(renderOutline);
+  for (let i = 1; i < numColors; i++) {
+    // Start from 1 to skip the background segment index.
+    const isHidden = segmentsHidden.has(i);
 
-  // @ts-ignore: setLabelOutlineWidth is not in the vtk.d.ts apparently
-  volumeActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-  volumeActor.getProperty().setLabelOutlineThickness(outlineWidth);
+    if (isHidden) {
+      outlineWidths[i - 1] = 0;
+      continue;
+    }
+
+    outlineWidths[i - 1] =
+      i === activeSegmentIndex
+        ? outlineWidth + toolGroupLabelmapConfig.activeSegmentOutlineWidthDelta
+        : outlineWidth;
+  }
+
+  actor.getProperty().setLabelOutlineThickness(outlineWidths);
 
   // Set visibility based on whether actor visibility is specifically asked
   // to be turned on/off (on by default) AND whether is is in active but
   // we are rendering inactive labelmap
   const visible = isActiveLabelmap || renderInactiveSegmentations;
-  volumeActor.setVisibility(visible);
+  actor.setVisibility(visible);
 }
 
 function _getLabelmapConfig(
@@ -413,7 +452,7 @@ function _needsTransferFunctionUpdate(
       renderFill,
       renderOutline,
       outlineWidth,
-      segmentColor,
+      segmentColor: segmentColor.slice(), // Create a copy
       segmentsHidden: new Set(segmentsHidden), // Create a copy
     });
 
@@ -487,19 +526,25 @@ function _removeLabelmapFromToolGroupViewports(
 }
 
 async function _addLabelmapToViewport(
-  viewport: Types.IVolumeViewport,
-  volumeId: string,
-  segmentationRepresentationUID: string
+  viewport: Types.IVolumeViewport | Types.IStackViewport,
+  labelmapData: LabelmapSegmentationData,
+  segmentationRepresentationUID
 ): Promise<void> {
   await addLabelmapToElement(
     viewport.element,
-    volumeId,
+    labelmapData,
     segmentationRepresentationUID
   );
 }
 
 export default {
+  getRepresentationRenderingConfig,
+  render,
+  removeSegmentationRepresentation,
+};
+
+export {
+  getRepresentationRenderingConfig,
   render,
-  addSegmentationRepresentation,
   removeSegmentationRepresentation,
 };

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

@@ -1,5 +1,4 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
 
 /**
  * Remove the labelmap segmentation representation from the viewport's HTML Element.
@@ -19,9 +18,7 @@ function removeLabelmapFromElement(
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
-  (viewport as Types.IVolumeViewport).removeVolumeActors([
-    segmentationRepresentationUID,
-  ]);
+  viewport.removeActors([segmentationRepresentationUID]);
 }
 
 export default removeLabelmapFromElement;

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/SegmentationDisplayTool.ts

@@ -15,9 +15,14 @@ import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../types/SegmentationStateTypes';
+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
@@ -143,26 +148,30 @@ class SegmentationDisplayTool extends BaseTool {
         const config = this._getMergedRepresentationsConfig(toolGroupId);
 
         const viewportsRenderList = [];
-        for (const viewport of toolGroupViewports) {
-          if (representation.type == Representations.Labelmap) {
-            viewportsRenderList.push(
-              labelmapDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          } else if (representation.type == Representations.Contour) {
-            viewportsRenderList.push(
-              contourDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          }
+
+        const renderers = {
+          [Representations.Labelmap]: labelmapDisplay,
+          [Representations.Contour]: contourDisplay,
+          [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) {
+          const renderedViewport = display.render(
+            viewport as Types.IVolumeViewport,
+            representation,
+            config
+          );
+
+          viewportsRenderList.push(renderedViewport);
+        }
         return viewportsRenderList;
       }
     );
@@ -175,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

@@ -0,0 +1,113 @@
+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 vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport';
+
+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;
+  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({
+    // @ts-ignore
+    actor: actor as vtkActor,
+    uid: actorUID,
+    clippingFilter,
+  });
+
+  viewport.resetCamera();
+  viewport.render();
+
+  setTimeout(() => {
+    viewport.getRenderer().resetCameraClippingRange();
+  }, 0);
+}
+
+export default addOrUpdateSurfaceToElement;

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

@@ -0,0 +1,3 @@
+import surfaceDisplay from './surfaceDisplay';
+
+export { surfaceDisplay };

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

@@ -0,0 +1,35 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Remove the surface representation from the viewport's HTML Element.
+ * NOTE: This function should not be called directly.
+ *
+ * @param element - The element that the segmentation is being added to.
+ * @param segmentationRepresentationUID - The UID of the surface representation to remove.
+ * @param removeFromCache - boolean
+ *
+ * @internal
+ */
+function removeContourFromElement(
+  element: HTMLDivElement,
+  segmentationRepresentationUID: string,
+  removeFromCache = false // Todo
+): void {
+  const enabledElement = getEnabledElement(element);
+  const { viewport } = enabledElement;
+
+  const actorEntries = (viewport as Types.IVolumeViewport).getActors();
+
+  // remove actors whose id has the same prefix as the segmentationRepresentationUID
+  const actorUIDsToRemove = actorEntries
+    .map(({ uid }) =>
+      uid.startsWith(segmentationRepresentationUID) ? uid : undefined
+    )
+    .filter(Boolean);
+
+  // @ts-ignore
+  viewport.removeActors(actorUIDsToRemove);
+}
+
+export default removeContourFromElement;