@cornerstonejs/tools 1.52.0 → 1.54.0

package/src/tools/annotation/splines/Spline.ts

@@ -26,6 +26,7 @@ type CurveSegmentDistanceSquared = {
 abstract class Spline implements ISpline {
   private _controlPoints: Types.Point2[] = [];
   private _resolution: number;
+  private _fixedResolution: boolean;
   private _closed: boolean;
   private _invalidated = false;
   private _curveSegments: SplineCurveSegment[];
@@ -35,6 +36,7 @@ abstract class Spline implements ISpline {
   constructor(props?: SplineProps) {
     this._controlPoints = [];
     this._resolution = props?.resolution ?? 20;
+    this._fixedResolution = props?.fixedResolution ?? false;
     this._closed = props?.closed ?? false;
     this._invalidated = true;
   }
@@ -61,7 +63,7 @@ abstract class Spline implements ISpline {
 
   /** Set the resolution of the spline curve */
   public set resolution(resolution: number) {
-    if (this._resolution === resolution) {
+    if (this._fixedResolution || this._resolution === resolution) {
       return;
     }
 
@@ -69,6 +71,16 @@ abstract class Spline implements ISpline {
     this.invalidated = true;
   }
 
+  /** Fixed resolution
+   *
+   * Linar spline is one of the splines that does not allow changing the resolution
+   * for better performance otherwise it would calculate and render 20 line segments
+   * instead of a single one..
+   */
+  public get fixedResolution() {
+    return this._fixedResolution;
+  }
+
   /** Flag that is set to true when the curve is already closed */
   public get closed(): boolean {
     return this._closed;

package/src/tools/base/AnnotationTool.ts

@@ -19,6 +19,7 @@ import {
   InteractionTypes,
   ToolProps,
   PublicToolProps,
+  IToolBinding,
 } from '../../types';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 
@@ -223,7 +224,7 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
       }
     }
 
-    for (let i = 0; i < points.length; i++) {
+    for (let i = 0; i < points?.length; i++) {
       const point = points[i];
       const annotationCanvasCoordinate = viewport.worldToCanvas(point);
 

package/src/tools/base/BaseTool.ts

@@ -1,9 +1,4 @@
-import {
-  StackViewport,
-  utilities,
-  BaseVolumeViewport,
-  VideoViewport,
-} from '@cornerstonejs/core';
+import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
 import { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 import StrategyCallbacks from '../../enums/StrategyCallbacks';

package/src/tools/base/ContourBaseTool.ts

@@ -3,6 +3,7 @@ import type { Types } from '@cornerstonejs/core';
 import {
   addAnnotation,
   getAnnotations,
+  getChildAnnotations,
 } from '../../stateManagement/annotation/annotationState';
 import type {
   Annotation,
@@ -13,9 +14,10 @@ import type {
   SVGDrawingHelper,
   AnnotationRenderContext,
 } from '../../types';
-import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
+import { drawPath as drawPathSvg } from '../../drawingSvg';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import AnnotationTool from './AnnotationTool';
+import { getContourHolesDataCanvas } from '../../utilities/contours';
 
 /**
  * A contour base class responsible for rendering contour instances such as
@@ -177,6 +179,37 @@ abstract class ContourBaseTool extends AnnotationTool {
     // noop method just to give a chance for child classes to override it
   }
 
+  /**
+   * Move an annotation and all its child annotations in a recursive way.
+   *
+   * That is useful when clicking on a spline contour to completely translate
+   * it to a different place. In that case all holes (child annotations) must
+   * also be translated too.
+   *
+   * @param annotation - Annotation
+   * @param worldPosDelta - Delta in world space
+   */
+  protected moveAnnotation(
+    annotation: Annotation,
+    worldPosDelta: Types.Point3
+  ): void {
+    const { points } = annotation.data.handles;
+
+    for (let i = 0, numPoints = points.length; i < numPoints; i++) {
+      const point = points[i];
+
+      point[0] += worldPosDelta[0];
+      point[1] += worldPosDelta[1];
+      point[2] += worldPosDelta[2];
+    }
+
+    annotation.invalidated = true;
+
+    getChildAnnotations(annotation).forEach((childAnnotation) =>
+      this.moveAnnotation(childAnnotation, worldPosDelta)
+    );
+  }
+
   /**
    * Get polyline points in world space.
    * Just to give a chance for child classes to override it.
@@ -184,7 +217,7 @@ abstract class ContourBaseTool extends AnnotationTool {
    * @returns Polyline points in world space
    */
   protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[] {
-    // Attenttion: `contour.polyline` is the new way to store a polyline but it
+    // Attention: `contour.polyline` is the new way to store a polyline but it
     // may be undefined because it was `data.polyline` before (fallback)
     return annotation.data.contour?.polyline ?? annotation.data.polyline;
   }
@@ -197,6 +230,12 @@ abstract class ContourBaseTool extends AnnotationTool {
   ): boolean {
     const { enabledElement, annotationStyle, svgDrawingHelper } = renderContext;
     const annotation = renderContext.annotation as ContourAnnotation;
+
+    // Do not render the contour because it must be rendered by the parent annotation
+    if (annotation.parentAnnotationUID) {
+      return;
+    }
+
     const { annotationUID } = annotation;
     const { viewport } = enabledElement;
     const { worldToCanvas } = viewport;
@@ -206,11 +245,14 @@ abstract class ContourBaseTool extends AnnotationTool {
     const { lineWidth, lineDash, color, fillColor, fillOpacity } =
       annotationStyle;
 
-    drawPolylineSvg(
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [polylineCanvasPoints, ...childContours];
+
+    drawPathSvg(
       svgDrawingHelper,
       annotationUID,
       'contourPolyline',
-      polylineCanvasPoints,
+      allContours,
       {
         color,
         lineDash,

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -20,10 +20,16 @@ import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { InterpolationManager } from '../../utilities/contours/interpolation';
+import {
+  addContourSegmentationAnnotation,
+  removeContourSegmentationAnnotation,
+} from '../../utilities/contourSegmentation';
+import { getToolGroupIdsWithSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
 
 /**
  * A base contour segmentation class responsible for rendering, registering
- * and unregistering contour segmentation annotations.
+ * and unregister contour segmentation annotations.
  */
 abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
@@ -70,8 +76,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
       throw new Error(`A contour segmentation must be active`);
     }
 
-    const { segmentationId, segmentationRepresentationUID } =
-      activeSegmentationRepresentation;
+    const { segmentationId } = activeSegmentationRepresentation;
     const segmentIndex =
       segmentIndexController.getActiveSegmentIndex(segmentationId);
 
@@ -82,7 +87,6 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
           segmentation: {
             segmentationId,
             segmentIndex,
-            segmentationRepresentationUID,
           },
         },
       }
@@ -94,11 +98,10 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     element: HTMLDivElement
   ): string {
     const annotationUID = super.addAnnotation(annotation, element);
-
     if (this.isContourSegmentationTool()) {
       const contourSegAnnotation = annotation as ContourSegmentationAnnotation;
 
-      this._registerContourSegmentationAnnotation(contourSegAnnotation);
+      addContourSegmentationAnnotation(contourSegAnnotation);
     }
 
     return annotationUID;
@@ -110,7 +113,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
    */
   protected cancelAnnotation(annotation: Annotation): void {
     if (this.isContourSegmentationTool()) {
-      this._unregisterContourSegmentationAnnotation(
+      removeContourSegmentationAnnotation(
         annotation as ContourSegmentationAnnotation
       );
     }
@@ -148,16 +151,21 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   ): boolean {
     const { annotation } = renderContext;
     const { invalidated } = annotation;
-
     // Render the annotation before triggering events
     const renderResult = super.renderAnnotationInstance(renderContext);
-
     if (invalidated && this.isContourSegmentationTool()) {
       const { segmentationId } = (<SplineContourSegmentationAnnotation>(
         annotation
       )).data.segmentation;
-
       triggerSegmentationDataModified(segmentationId);
+
+      // check which other viewport is rendering the same segmentationId
+      // and trigger the event for them to be able to render the segmentation
+      // annotation as well
+
+      const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
+
+      triggerAnnotationRenderForToolGroupIds(toolGroupIds);
     }
 
     return renderResult;
@@ -173,14 +181,16 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   }): Record<string, any> {
     const { toolGroupId } = this;
     const annotation = context.annotation as ContourSegmentationAnnotation;
-    const { segmentationRepresentationUID, segmentationId, segmentIndex } =
-      annotation.data.segmentation;
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = segmentationState.getSegmentation(segmentationId);
     const segmentationRepresentation =
-      segmentationState.getSegmentationRepresentationByUID(
-        toolGroupId,
-        segmentationRepresentationUID
-      );
+      this._getSegmentationRepresentation(segmentationId);
 
+    if (!segmentationRepresentation) {
+      // return defaults if no segmentation representation is found
+      return {};
+    }
+    const { segmentationRepresentationUID } = segmentationRepresentation;
     const { active } = segmentationRepresentation;
     const { autoGenerated } = annotation;
     const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
@@ -252,6 +262,11 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
       fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
     }
 
+    // Change the line thickness when the mouse is over the contour segment
+    if (segmentation.activeSegmentIndex === segmentIndex) {
+      lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
+    }
+
     lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
     fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
 
@@ -272,37 +287,31 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     };
   }
 
-  private _registerContourSegmentationAnnotation(
-    annotation: ContourSegmentationAnnotation
-  ) {
-    const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = segmentationState.getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+  private _getSegmentationRepresentation(segmentationId) {
+    const segmentationRepresentations =
+      segmentationState.getSegmentationRepresentations(this.toolGroupId);
 
-    let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+    const validSegmentationRepresentations = segmentationRepresentations.filter(
+      (representation) => representation.segmentationId === segmentationId
+    );
 
-    if (!annotationsUIDsSet) {
-      annotationsUIDsSet = new Set();
-      annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+    if (!validSegmentationRepresentations) {
+      console.warn(
+        `No segmentation representation found for toolGroupId: ${this.toolGroupId}`
+      );
+      return;
     }
 
-    annotationsUIDsSet.add(annotation.annotationUID);
-  }
-
-  private _unregisterContourSegmentationAnnotation(
-    annotation: ContourSegmentationAnnotation
-  ) {
-    const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = segmentationState.getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
-    const annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
-
-    annotationsUIDsSet.delete(annotation.annotationUID);
-
-    // Delete segmentIndex Set if there is no more annotations
-    if (!annotationsUIDsSet.size) {
-      annotationUIDsMap.delete(segmentIndex);
+    if (
+      segmentationState.getSegmentationRepresentations(this.toolGroupId)
+        .length > 1
+    ) {
+      console.warn(
+        'Multiple segmentation representations detected for this tool group. The first one will be used.'
+      );
     }
+
+    return validSegmentationRepresentations[0];
   }
 }
 

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

@@ -10,6 +10,7 @@ const defaultContourConfig: ContourConfig = {
   outlineDashActive: undefined,
   outlineDashInactive: undefined,
   outlineDashAutoGenerated: '5,3',
+  activeSegmentOutlineWidthDelta: 0,
   renderFill: true,
   fillAlpha: 0.5,
   fillAlphaInactive: 0.3,

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

@@ -2,6 +2,7 @@ import {
   getEnabledElementByIds,
   Types,
   StackViewport,
+  BaseVolumeViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
@@ -11,9 +12,9 @@ import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
-import { addOrUpdateContourSets } from './addOrUpdateContourSets';
+import { addOrUpdateVTKContourSets } from './vtkContour/addOrUpdateVTKContourSets';
 import removeContourFromElement from './removeContourFromElement';
-import { deleteConfigCache } from './contourConfigCache';
+import { deleteConfigCache } from './vtkContour/contourConfigCache';
 
 /**
  * It removes a segmentation representation from the tool group's viewports and
@@ -66,27 +67,99 @@ async function render(
 ): Promise<void> {
   const { segmentationId } = representationConfig;
   const segmentation = SegmentationState.getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    return;
+  }
+
   const contourData = segmentation.representationData[Representations.Contour];
-  const { geometryIds } = contourData;
 
-  // 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 (viewport instanceof StackViewport) {
+  const { geometryIds, annotationUIDsMap } = contourData;
+
+  if (!geometryIds?.length && !annotationUIDsMap?.size) {
     return;
   }
 
-  if (!geometryIds?.length) {
-    // This is a normal occurrence when contours activated, but not yet drawn
+  // this means we would like to use vtk actors for contour data
+
+  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.
     return;
   }
 
   // add the contour sets to the viewport
-  addOrUpdateContourSets(
+  addOrUpdateVTKContourSets(
     viewport,
     geometryIds,
     representationConfig,
     toolGroupConfig
   );
+
+  /**
+   * The following logic could be added if we want to support the use case
+   * where the contour representation data is initiated using annotations
+   * in the state from the get-go , and not when the user draws a contour.
+   */
+  // if (contourData?.points?.length) {
+  //   // contourData = createAnnotationsFromPoints(contourData.points);
+  //   const contourSegmentationAnnotation = {
+  //     annotationUID: csUtils.uuidv4(),
+  //     data: {
+  //       contour: {
+  //         closed: true,
+  //         polyline: contourData.points,
+  //       },
+  //       segmentation: {
+  //         segmentationId,
+  //         segmentIndex: 1, // Todo
+  //         segmentationRepresentationUID:
+  //           representationConfig.segmentationRepresentationUID,
+  //       },
+  //     },
+  //     highlighted: false,
+  //     invalidated: false,
+  //     isLocked: false,
+  //     isVisible: true,
+  //     metadata: {
+  //       toolName: 'PlanarFreehandContourSegmentationTool',
+  //       FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+  //       viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+  //     },
+  //   };
+
+  //   addAnnotation(contourSegmentationAnnotation, viewport.element);
+  // } else if (
+  //   !contourData &&
+  //   polySeg.canComputeRequestedRepresentation(
+  //     representationConfig.segmentationRepresentationUID
+  //   )
+  // ) {
+  // contourData = await polySeg.computeAndAddContourRepresentation(
+  //   segmentationId,
+  //   {
+  //     segmentationRepresentationUID:
+  //       representationConfig.segmentationRepresentationUID,
+  //     viewport,
+  //   }
+  // );
+  // }
+
+  // if (contourData?.geometryIds?.length) {
+  //   handleVTKContour({
+  //     viewport,
+  //     representationConfig,
+  //     toolGroupConfig,
+  //     geometryIds: contourData.geometryIds,
+  //   });
+  // } else if (contourData.annotationUIDsMap?.size) {
+  //   handleContourAnnotationSegmentation({
+  //     viewport,
+  //     representationConfig,
+  //     toolGroupConfig,
+  //     annotationUIDsMap: contourData.annotationUIDsMap,
+  //   });
+  // }
 }
 
 function _removeContourFromToolGroupViewports(

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

@@ -30,6 +30,8 @@ function removeContourFromElement(
 
   // @ts-ignore
   viewport.removeActors(actorUIDsToRemove);
+
+  // Todo: add the logic to remove the svg contour segmentation representations as well
 }
 
 export default removeContourFromElement;

package/src/tools/displayTools/Contour/{addContourSetsToElement.ts → vtkContour/addContourSetsToElement.ts}

@@ -13,7 +13,7 @@ import {
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
 
 export function addContourSetsToElement(

package/src/tools/displayTools/Contour/{addOrUpdateContourSets.ts → vtkContour/addOrUpdateVTKContourSets.ts}

@@ -3,11 +3,11 @@ import { Types } from '@cornerstonejs/core';
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { addContourSetsToElement } from './addContourSetsToElement';
-import { updateContourSets } from './updateContourSets';
+import { updateVTKContourSets } from './updateVTKContourSets';
 
-export function addOrUpdateContourSets(
+export function addOrUpdateVTKContourSets(
   viewport: Types.IVolumeViewport,
   geometryIds: string[],
   contourRepresentation: ToolGroupSpecificContourRepresentation,
@@ -17,7 +17,7 @@ export function addOrUpdateContourSets(
   const actorUID = `CONTOUR_${segmentationRepresentationUID}`;
   const actor = viewport.getActor(actorUID);
 
-  const addOrUpdateFn = actor ? updateContourSets : addContourSetsToElement;
+  const addOrUpdateFn = actor ? updateVTKContourSets : addContourSetsToElement;
   addOrUpdateFn(
     viewport,
     geometryIds,

package/src/tools/displayTools/Contour/{updateContourSets.ts → vtkContour/updateVTKContourSets.ts}

@@ -4,11 +4,11 @@ import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
 import { getSegmentSpecificConfig } from './utils';
 
-export function updateContourSets(
+export function updateVTKContourSets(
   viewport: Types.IVolumeViewport,
   geometryIds: string[],
   contourRepresentation: ToolGroupSpecificContourRepresentation,

package/src/tools/displayTools/Contour/{utils.ts → vtkContour/utils.ts}

@@ -2,7 +2,7 @@ import { Enums, Types } from '@cornerstonejs/core';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import { ToolGroupSpecificContourRepresentation } from '../../../types';
+import { ToolGroupSpecificContourRepresentation } from '../../../../types';
 
 /**
  * If the segment specific config exists for the given segment id, it returns

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

@@ -36,7 +36,7 @@ async function addLabelmapToElement(
   const immediateRender = false;
   const suppressEvents = true;
 
-  if (isVolumeSegmentation(labelMapData)) {
+  if (isVolumeSegmentation(labelMapData, viewport)) {
     // 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

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

@@ -1,4 +1,13 @@
 import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
+import {
+  validate as validateLabelmap,
+  validatePublic as validateLabelmapPublic,
+} from './validateLabelmap';
 
-export { labelmapDisplay, labelmapConfig };
+export {
+  labelmapDisplay,
+  labelmapConfig,
+  validateLabelmap,
+  validateLabelmapPublic,
+};

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;
     }