@cornerstonejs/tools 1.32.3 → 1.34.0

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

@@ -1,10 +1,15 @@
 import {
   getEnabledElement,
   addVolumesToViewports,
+  addImageSlicesToViewports,
   Types,
   Enums,
 } from '@cornerstonejs/core';
-
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+} from '../../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
 /**
  * It adds a labelmap segmentation representation of the viewport's HTML Element.
  * NOTE: This function should not be called directly.
@@ -17,7 +22,7 @@ import {
  */
 async function addLabelmapToElement(
   element: HTMLDivElement,
-  volumeId: string,
+  labelMapData: LabelmapSegmentationData,
   segmentationRepresentationUID: string
 ): Promise<void> {
   const enabledElement = getEnabledElement(element);
@@ -31,27 +36,51 @@ async function addLabelmapToElement(
   const immediateRender = false;
   const suppressEvents = true;
 
-  // Todo: Right now we use MIP blend mode for the labelmap, since the
-  // composite blend mode has a non linear behavior regarding fill and line
-  // opacity. This should be changed to a custom labelmap blendMode which does
-  // what composite does, but with a linear behavior.
-  const volumeInputs: Types.IVolumeInput[] = [
-    {
-      volumeId,
-      actorUID: segmentationRepresentationUID,
-      visibility,
-      blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
-    },
-  ];
+  if (isVolumeSegmentation(labelMapData)) {
+    // Todo: Right now we use MIP blend mode for the labelmap, since the
+    // composite blend mode has a non linear behavior regarding fill and line
+    // opacity. This should be changed to a custom labelmap blendMode which does
+    // what composite does, but with a linear behavior.
+    const volumeInputs: Types.IVolumeInput[] = [
+      {
+        volumeId: labelMapData.volumeId,
+        actorUID: segmentationRepresentationUID,
+        visibility,
+        blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
+      },
+    ];
+
+    // Add labelmap volumes to the viewports to be be rendered, but not force the render
+    await addVolumesToViewports(
+      renderingEngine,
+      volumeInputs,
+      [viewportId],
+      immediateRender,
+      suppressEvents
+    );
+  } else {
+    // We can use the current imageId in the viewport to get the segmentation imageId
+    // which later is used to create the actor and mapper.
+    const segmentationImageId = (
+      labelMapData as LabelmapSegmentationDataStack
+    ).imageIdReferenceMap.get(viewport.getCurrentImageId());
+
+    const stackInputs: Types.IStackInput[] = [
+      {
+        imageId: segmentationImageId,
+        actorUID: segmentationRepresentationUID,
+      },
+    ];
 
-  // Add labelmap volumes to the viewports to be be rendered, but not force the render
-  await addVolumesToViewports(
-    renderingEngine,
-    volumeInputs,
-    [viewportId],
-    immediateRender,
-    suppressEvents
-  );
+    // Add labelmap volumes to the viewports to be be rendered, but not force the render
+    await addImageSlicesToViewports(
+      renderingEngine,
+      stackInputs,
+      [viewportId],
+      immediateRender,
+      suppressEvents
+    );
+  }
 }
 
 export default addLabelmapToElement;

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

@@ -15,6 +15,7 @@ import { getToolGroup } from '../../../store/ToolGroupManager';
 import type {
   LabelmapConfig,
   LabelmapRenderingConfig,
+  LabelmapSegmentationData,
 } from '../../../types/LabelmapTypes';
 import {
   RepresentationPublicInput,
@@ -25,6 +26,7 @@ import {
 import addLabelmapToElement from './addLabelmapToElement';
 
 import removeLabelmapFromElement from './removeLabelmapFromElement';
+import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
 
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
@@ -176,7 +178,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> {
@@ -192,29 +194,50 @@ async function render(
   const segmentation = SegmentationState.getSegmentation(segmentationId);
   const labelmapData =
     segmentation.representationData[Representations.Labelmap];
-  const { volumeId: labelmapUID } = labelmapData;
 
-  const labelmap = cache.getVolume(labelmapUID);
+  let actorEntry = viewport.getActor(segmentationRepresentationUID);
+  if (isVolumeSegmentation(labelmapData)) {
+    const { volumeId: labelmapUID } = labelmapData;
 
-  if (!labelmap) {
-    throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
-  }
+    const labelmap = cache.getVolume(labelmapUID);
 
-  if (!isSameFrameOfReference(viewport, labelmapData?.referencedVolumeId)) {
-    return;
-  }
-  let actorEntry = viewport.getActor(segmentationRepresentationUID);
+    if (!labelmap) {
+      throw new Error(`No Labelmap found for volumeId: ${labelmapUID}`);
+    }
 
-  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 (!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 {
+    // 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 +287,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
@@ -327,24 +349,32 @@ function _setLabelmapColorAndOpacity(
     }
   }
 
-  volumeActor.getProperty().setRGBTransferFunction(0, cfun);
-
-  ofun.setClamping(false);
-  volumeActor.getProperty().setScalarOpacity(0, ofun);
+  const actor = actorEntry.actor as Types.Actor;
 
-  volumeActor.getProperty().setInterpolationTypeToNearest();
+  // @ts-ignore
+  actor.getProperty().setRGBTransferFunction(0, cfun);
 
-  volumeActor.getProperty().setUseLabelOutline(renderOutline);
+  ofun.setClamping(false);
 
-  // @ts-ignore: setLabelOutlineWidth is not in the vtk.d.ts apparently
-  volumeActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-  volumeActor.getProperty().setLabelOutlineThickness(outlineWidth);
+  // @ts-ignore
+  actor.getProperty().setScalarOpacity(0, ofun);
+  // @ts-ignore
+  actor.getProperty().setInterpolationTypeToNearest();
+
+  if (utilities.actorIsA(actorEntry, 'vtkVolume')) {
+    // @ts-ignore
+    actor.getProperty().setUseLabelOutline(renderOutline);
+    // @ts-ignore
+    actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+    // @ts-ignore
+    actor.getProperty().setLabelOutlineThickness(outlineWidth);
+  }
 
   // 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(
@@ -490,13 +520,13 @@ 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
   );
 }

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

@@ -1,6 +1,9 @@
 import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
 import { cache } from '@cornerstonejs/core';
-import { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
+import type {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataVolume,
+} from '../../../types/LabelmapTypes';
 
 function validate(segmentationInput: SegmentationPublicInput): void {
   if (!segmentationInput.representation.data) {
@@ -12,18 +15,21 @@ function validate(segmentationInput: SegmentationPublicInput): void {
   const representationData = segmentationInput.representation
     .data as LabelmapSegmentationData;
 
-  if (!representationData.volumeId) {
-    throw new Error(
-      'The segmentationInput.representationData.volumeId is undefined, please provide a valid representationData.volumeId'
+  if ('volumeId' in representationData) {
+    // volumetric labelmap
+    const cachedVolume = cache.getVolume(
+      (representationData as LabelmapSegmentationDataVolume).volumeId
     );
-  }
-
-  const cachedVolume = cache.getVolume(representationData.volumeId);
 
-  if (!cachedVolume) {
-    throw new Error(
-      `volumeId of ${representationData.volumeId} not found in cache, you should load and cache volume before adding segmentation`
-    );
+    if (!cachedVolume) {
+      throw new Error(
+        `volumeId of ${
+          (representationData as LabelmapSegmentationDataVolume).volumeId
+        } not found in cache, you should load and cache volume before adding segmentation`
+      );
+    }
+  } else {
+    // I don't think we need this check since there is no guarantee that the stack is cached.
   }
 }
 

package/src/tools/segmentation/BrushTool.ts

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { utilities as csUtils, getEnabledElement } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 
 import type { Types } from '@cornerstonejs/core';
@@ -19,7 +19,7 @@ import {
   fillInsideCircle,
 } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
-import { Events, ToolModes } from '../../enums';
+import { Events, ToolModes, SegmentationRepresentations } from '../../enums';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import {
   resetElementCursor,
@@ -34,7 +34,11 @@ import {
   state as segmentationState,
   activeSegmentation,
 } from '../../stateManagement/segmentation';
-import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import {
+  LabelmapSegmentationDataVolume,
+  LabelmapSegmentationDataStack,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 
 /**
  * @public
@@ -42,9 +46,11 @@ import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
 class BrushTool extends BaseTool {
   static toolName;
   private _editData: {
-    segmentation: Types.IImageVolume;
-    imageVolume: Types.IImageVolume; //
     segmentsLocked: number[]; //
+    segmentationRepresentationUID?: string;
+    imageIdReferenceMap?: Map<string, string>;
+    volumeId?: string;
+    referencedVolumeId?: string;
   } | null;
   private _hoverData?: {
     brushCursor: any;
@@ -108,10 +114,6 @@ class BrushTool extends BaseTool {
     const enabledElement = getEnabledElement(element);
     const { viewport, renderingEngine } = enabledElement;
 
-    if (viewport instanceof StackViewport) {
-      throw new Error('Not implemented yet');
-    }
-
     const toolGroupId = this.toolGroupId;
 
     const activeSegmentationRepresentation =
@@ -122,30 +124,78 @@ class BrushTool extends BaseTool {
       );
     }
 
-    const { segmentationId, type } = activeSegmentationRepresentation;
+    const { segmentationId, type, segmentationRepresentationUID } =
+      activeSegmentationRepresentation;
+
+    if (type === SegmentationRepresentations.Contour) {
+      throw new Error('Not implemented yet');
+    }
+
     const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
 
     const { representationData } =
       segmentationState.getSegmentation(segmentationId);
 
-    // Todo: are we going to support contour editing with this tool?
-    const { volumeId } = representationData[type] as LabelmapSegmentationData;
-    const segmentation = cache.getVolume(volumeId);
+    const labelmapData =
+      representationData[SegmentationRepresentations.Labelmap];
 
-    const actors = viewport.getActors();
+    const viewportIdsToRender = [viewport.id];
 
-    // Note: For tools that need the source data. Assumed to use
-    // First volume actor for now.
-    const firstVolumeActorUID = actors[0].uid;
-    const imageVolume = cache.getVolume(firstVolumeActorUID);
+    if (isVolumeSegmentation(labelmapData)) {
+      const { volumeId } = representationData[
+        type
+      ] as LabelmapSegmentationDataVolume;
+      const actors = viewport.getActors();
+
+      // Note: For tools that need the source data. Assumed to use
+      // First volume actor for now.
+      const firstVolumeActorUID = actors[0].uid;
+
+      this._editData = {
+        volumeId,
+        referencedVolumeId: firstVolumeActorUID,
+        segmentsLocked,
+        segmentationRepresentationUID,
+      };
+    } else {
+      const { imageIdReferenceMap } =
+        labelmapData as LabelmapSegmentationDataStack;
+
+      const currentImageId = viewport.getCurrentImageId();
+
+      if (!imageIdReferenceMap.get(currentImageId)) {
+        // if there is no stack segmentation slice for the current image
+        // we should not allow the user to perform any operation
+        return;
+      }
 
-    const viewportIdsToRender = [viewport.id];
+      // here we should identify if we can perform sphere manipulation
+      // for these stack of images, if the metadata is not present
+      // to create a volume or if there are inconsistencies between
+      // the image metadata we should not allow the sphere manipulation
+      // and should throw an error or maybe simply just allow circle manipulation
+      // and not sphere manipulation
+      if (this.configuration.activeStrategy.includes('SPHERE')) {
+        console.warn(
+          'Sphere manipulation is not supported for this stack of images yet'
+        );
+        return;
+
+        // Todo: add sphere manipulation support for stacks of images
+        // we should basically check if the stack constructs a valid volume
+        // meaning all the metadata is present and consistent
+        // then we should create a volume and use it as a reference
+        // ideally a tiny volume that does not exceeds the boundary of the
+        // sphere brush size
+        // csUtils.isValidVolume(referencedImageIds
+      }
 
-    this._editData = {
-      segmentation,
-      imageVolume,
-      segmentsLocked,
-    };
+      this._editData = {
+        imageIdReferenceMap,
+        segmentsLocked,
+        segmentationRepresentationUID,
+      };
+    }
 
     this._activateDraw(element);
 
@@ -240,8 +290,6 @@ class BrushTool extends BaseTool {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine } = enabledElement;
 
-    const { imageVolume, segmentation, segmentsLocked } = this._editData;
-
     this.updateCursor(evt);
 
     const {
@@ -261,11 +309,9 @@ class BrushTool extends BaseTool {
     );
 
     const operationData = {
+      ...this._editData,
       points: data.handles.points,
-      volume: segmentation, // todo: just pass the segmentationId instead
-      imageVolume,
       segmentIndex,
-      segmentsLocked,
       viewPlaneNormal,
       toolGroupId: this.toolGroupId,
       segmentationId,
@@ -340,7 +386,6 @@ class BrushTool extends BaseTool {
     const eventData = evt.detail;
     const { element } = eventData;
 
-    const { imageVolume, segmentation, segmentsLocked } = this._editData;
     const {
       segmentIndex,
       segmentationId,
@@ -356,21 +401,13 @@ class BrushTool extends BaseTool {
     resetElementCursor(element);
 
     const enabledElement = getEnabledElement(element);
-    const { viewport } = enabledElement;
 
-    this._editData = null;
     this.updateCursor(evt);
 
-    if (viewport instanceof StackViewport) {
-      throw new Error('Not implemented yet');
-    }
-
     const operationData = {
       points: data.handles.points,
-      volume: segmentation,
-      imageVolume,
+      ...this._editData,
       segmentIndex,
-      segmentsLocked,
       viewPlaneNormal,
       toolGroupId: this.toolGroupId,
       segmentationId,
@@ -380,6 +417,8 @@ class BrushTool extends BaseTool {
         this.configuration.strategySpecificConfiguration,
     };
 
+    this._editData = null;
+
     this.applyActiveStrategy(enabledElement, operationData);
   };
 

package/src/tools/segmentation/CircleScissorsTool.ts

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { cache, getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 import { BaseTool } from '../base';
@@ -25,7 +25,12 @@ import {
   config as segmentationConfig,
 } from '../../stateManagement/segmentation';
 import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 
 /**
  * Tool for manipulating segmentation data by drawing a circle. It acts on the
@@ -38,9 +43,12 @@ class CircleScissorsTool extends BaseTool {
   static toolName;
   editData: {
     annotation: any;
-    segmentation: any;
     segmentIndex: number;
-    segmentationId: string;
+    //
+    volumeId: string;
+    referencedVolumeId: string;
+    imageIdReferenceMap: Map<string, string>;
+    //
     segmentsLocked: number[];
     segmentColor: [number, number, number, number];
     viewportIdsToRender: string[];
@@ -49,6 +57,7 @@ class CircleScissorsTool extends BaseTool {
     newAnnotation?: boolean;
     hasMoved?: boolean;
     centerCanvas?: Array<number>;
+    segmentationRepresentationUID?: string;
   } | null;
   isDrawing: boolean;
   isHandleOutsideImage: boolean;
@@ -116,8 +125,13 @@ class CircleScissorsTool extends BaseTool {
     const { representationData } = getSegmentation(segmentationId);
 
     // Todo: are we going to support contour editing with rectangle scissors?
-    const { volumeId } = representationData[type] as LabelmapSegmentationData;
-    const segmentation = cache.getVolume(volumeId);
+    const labelmapData = representationData[type];
+
+    if (!labelmapData) {
+      throw new Error(
+        'No labelmap data found for the active segmentation, create one before using scissors tool'
+      );
+    }
 
     // Todo: Used for drawing the svg only, we might not need it at all
     const annotation = {
@@ -145,7 +159,6 @@ class CircleScissorsTool extends BaseTool {
 
     this.editData = {
       annotation,
-      segmentation,
       centerCanvas: canvasPos,
       segmentIndex,
       segmentationId,
@@ -156,7 +169,27 @@ class CircleScissorsTool extends BaseTool {
       movingTextBox: false,
       newAnnotation: true,
       hasMoved: false,
-    };
+      segmentationRepresentationUID,
+    } as any;
+
+    if (isVolumeSegmentation(labelmapData as LabelmapSegmentationData)) {
+      const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+      const segmentation = cache.getVolume(volumeId);
+
+      this.editData = {
+        ...this.editData,
+        volumeId,
+        referencedVolumeId: segmentation.referencedVolumeId,
+      };
+    } else {
+      const { imageIdReferenceMap } =
+        labelmapData as LabelmapSegmentationDataStack;
+
+      this.editData = {
+        ...this.editData,
+        imageIdReferenceMap,
+      };
+    }
 
     this._activateDraw(element);
 
@@ -221,15 +254,7 @@ class CircleScissorsTool extends BaseTool {
     const eventDetail = evt.detail;
     const { element } = eventDetail;
 
-    const {
-      annotation,
-      newAnnotation,
-      hasMoved,
-      segmentation,
-      segmentIndex,
-      segmentsLocked,
-      segmentationId,
-    } = this.editData;
+    const { annotation, newAnnotation, hasMoved } = this.editData;
     const { data } = annotation;
     const { viewPlaneNormal, viewUp } = annotation.metadata;
 
@@ -244,25 +269,17 @@ class CircleScissorsTool extends BaseTool {
     resetElementCursor(element);
 
     const enabledElement = getEnabledElement(element);
-    const { viewport } = enabledElement;
-
-    this.editData = null;
-    this.isDrawing = false;
-
-    if (viewport instanceof StackViewport) {
-      throw new Error('Not implemented yet');
-    }
 
     const operationData = {
+      ...this.editData,
       points: data.handles.points,
-      volume: segmentation,
-      segmentIndex,
-      segmentsLocked,
       viewPlaneNormal,
-      segmentationId,
       viewUp,
     };
 
+    this.editData = null;
+    this.isDrawing = false;
+
     this.applyActiveStrategy(enabledElement, operationData);
   };