@cornerstonejs/tools 1.53.0 → 1.54.1

package/src/utilities/segmentation/getUniqueSegmentIndices.ts

@@ -0,0 +1,76 @@
+import { Types, cache } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+
+/**
+ * Retrieves the unique segment indices from a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @returns An array of unique segment indices.
+ * @throws If no geometryIds are found for the segmentationId.
+ */
+function getUniqueSegmentIndices(segmentationId) {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (segmentation.type === SegmentationRepresentations.Labelmap) {
+    const labelmapData =
+      segmentation.representationData[SegmentationRepresentations.Labelmap];
+
+    const keySet = new Set();
+
+    if (isVolumeSegmentation(labelmapData)) {
+      const volume = cache.getVolume(segmentationId);
+      const scalarData = volume.getScalarData();
+
+      for (let i = 0; i < scalarData.length; i++) {
+        const segmentIndex = scalarData[i];
+        if (segmentIndex !== 0) {
+          keySet.add(segmentIndex);
+        }
+      }
+    } else {
+      labelmapData.imageIdReferenceMap.forEach((segmentationImageId) => {
+        const image = cache.getImage(segmentationImageId);
+        const scalarData = image.getPixelData();
+
+        for (let i = 0; i < scalarData.length; i++) {
+          const segmentIndex = scalarData[i];
+          if (segmentIndex !== 0) {
+            keySet.add(segmentIndex);
+          }
+        }
+      });
+    }
+
+    return Array.from(keySet)
+      .map((it) => parseInt(it as string))
+      .sort();
+  } else if (segmentation.type === SegmentationRepresentations.Contour) {
+    const annotationUIDsMap =
+      segmentation.representationData.CONTOUR?.annotationUIDsMap;
+
+    const indices = new Set(annotationUIDsMap.keys());
+    const geometryIds = segmentation.representationData.CONTOUR?.geometryIds;
+
+    if (!geometryIds) {
+      throw new Error(
+        `No geometryIds found for segmentationId ${segmentationId}`
+      );
+    }
+
+    geometryIds.forEach((geometryId) => {
+      const geometry = cache.getGeometry(geometryId) as Types.IGeometry;
+      indices.add((geometry.data as Types.IContourSet).getSegmentIndex());
+    });
+
+    return Array.from(indices.values()).sort();
+  } else if (segmentation.type === SegmentationRepresentations.Surface) {
+    const geometryIds =
+      segmentation.representationData.SURFACE?.geometryIds ?? [];
+
+    return Array.from(geometryIds.keys());
+  }
+}
+
+export { getUniqueSegmentIndices };

package/src/utilities/segmentation/index.ts

@@ -20,6 +20,10 @@ import contourAndFindLargestBidirectional from './contourAndFindLargestBidirecti
 import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
 import { invalidateBrushCursor } from './invalidateBrushCursor';
+import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
+import { getSegmentAtWorldPoint } from './getSegmentAtWorldPoint';
+import { getSegmentAtLabelmapBorder } from './getSegmentAtLabelmapBorder';
+import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 
 export {
   thresholdVolumeByRange,
@@ -40,4 +44,8 @@ export {
   createBidirectionalToolData,
   segmentContourAction,
   invalidateBrushCursor,
+  getUniqueSegmentIndices,
+  getSegmentAtWorldPoint,
+  getSegmentAtLabelmapBorder,
+  getHoveredContourSegmentationAnnotation,
 };

package/src/utilities/triggerAnnotationRenderForToolGroupIds.ts

@@ -0,0 +1,38 @@
+import { getRenderingEngine, type Types } from '@cornerstonejs/core';
+import triggerAnnotationRender from './triggerAnnotationRender';
+import { getToolGroup } from '../store/ToolGroupManager';
+
+/**
+ * Triggers annotation rendering for the specified tool group IDs.
+ *
+ * @param toolGroupIds - An array of tool group IDs.
+ */
+export function triggerAnnotationRenderForToolGroupIds(
+  toolGroupIds: string[]
+): void {
+  toolGroupIds.forEach((toolGroupId) => {
+    const toolGroup = getToolGroup(toolGroupId);
+
+    if (!toolGroup) {
+      console.warn(`ToolGroup not available for ${toolGroupId}`);
+      return;
+    }
+
+    const viewportsInfo = toolGroup.getViewportsInfo();
+
+    viewportsInfo.forEach((viewportInfo) => {
+      const { renderingEngineId, viewportId } = viewportInfo;
+
+      const renderingEngine = getRenderingEngine(renderingEngineId);
+      if (!renderingEngine) {
+        console.warn(`RenderingEngine not available for ${renderingEngineId}`);
+        return;
+      }
+
+      const viewport = renderingEngine.getViewport(viewportId);
+      triggerAnnotationRender(viewport.element);
+    });
+  });
+}
+
+export default triggerAnnotationRenderForToolGroupIds;

package/src/workers/clippingPlaneWorker.js

@@ -0,0 +1,87 @@
+import { expose } from 'comlink';
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import vtkClipClosedSurface from '@kitware/vtk.js/Filters/General/ClipClosedSurface';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+
+const obj = {
+  /**
+   * Clips a 3D surface using provided planes and updates the cache and progress.
+   * The function takes in information about the planes and the polygon data, and applies a clipping filter.
+   * It then updates the cache and progress based on the processed data.
+   *
+   * @param clipInfo - Contains information about the planes and the polygon data.
+   * @param updateProgress - Callback function to update the progress of the clipping process.
+   * @param updateCache - Callback function to update the cache with the clipped data.
+   *
+   * @throws Will throw an error if the clipping process encounters an issue.
+   */
+  clipSurfaceWithPlanes(
+    { planesInfo, pointsAndPolys },
+    progressCallback,
+    updateCacheCallback
+  ) {
+    const numberOfPlanes = planesInfo.length;
+    const clippingFilter = vtkClipClosedSurface.newInstance({
+      clippingPlanes: [],
+      activePlaneId: 2,
+      passPointData: false,
+    });
+    clippingFilter.setGenerateOutline(true);
+    clippingFilter.setGenerateFaces(false);
+
+    const plane1 = vtkPlane.newInstance();
+    const plane2 = vtkPlane.newInstance();
+
+    try {
+      for (const [index, planeInfo] of planesInfo.entries()) {
+        const { sliceIndex, planes } = planeInfo;
+
+        const polyDataResults = new Map();
+        for (const polyDataInfo of pointsAndPolys) {
+          const { points, polys, id } = polyDataInfo;
+
+          const surfacePolyData = vtkPolyData.newInstance();
+          surfacePolyData.getPoints().setData(points, 3);
+          surfacePolyData.getPolys().setData(polys, 3);
+
+          clippingFilter.setInputData(surfacePolyData);
+
+          // Reusable array for clipping planes
+          const clippingPlanes = [plane1, plane2];
+
+          // Directly update plane instances
+          plane1.setOrigin(planes[0].origin);
+          plane1.setNormal(planes[0].normal);
+          plane2.setOrigin(planes[1].origin);
+          plane2.setNormal(planes[1].normal);
+
+          clippingFilter.setClippingPlanes(clippingPlanes);
+          clippingFilter.update();
+
+          const polyData = clippingFilter.getOutputData();
+
+          if (polyData) {
+            polyDataResults.set(id, {
+              points: polyData.getPoints().getData(),
+              lines: polyData.getLines().getData(),
+            });
+          }
+        }
+
+        progressCallback({ progress: (index + 1) / numberOfPlanes });
+
+        updateCacheCallback({ sliceIndex, polyDataResults });
+      }
+    } catch (e) {
+      console.error('Error during processing', e);
+    } finally {
+      // Cleanup on completion
+      pointsAndPolys = null;
+      clippingFilter.delete();
+      plane1.delete();
+      plane2.delete();
+    }
+  },
+};
+
+expose(obj);

package/src/workers/polySegConverters.js

@@ -0,0 +1,467 @@
+import { expose } from 'comlink';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import ICRPolySeg from '@icr/polyseg-wasm';
+import { utilities } from '@cornerstonejs/core';
+import { getBoundingBoxAroundShapeWorld } from '../utilities/boundingBox';
+import { pointInShapeCallback } from '../utilities';
+import { isPointInsidePolyline3D } from '../utilities/math/polyline';
+
+/**
+ * Object containing methods for converting between different representations of
+ * segmentations (e.g., contour, labelmap, surface, etc.) These logics
+ * are used in a webworker to avoid blocking the main thread. You can
+ * search for workerManager.executeTask('polySeg', ...) to see
+ * how these methods are used.
+ *
+ * See also the webworker docs at packages/docs/docs/concepts/cornerstone-core/web-worker.md
+ * to learn more about how to use webworkers in the context of Cornerstone.
+ */
+const polySegConverters = {
+  /**
+   * The polySeg instance that is used to convert between different representations
+   */
+  polySeg: null,
+  /**
+   * Utilities to keep track of the initialization state of the polySeg instance
+   * and avoid initializing it multiple times
+   */
+  polySegInitializing: false,
+  polySegInitializingPromise: null,
+  /**
+   * This method initializes the polySeg instance and sets it to this.polySeg
+   */
+  async initializePolySeg(progressCallback) {
+    if (this.polySegInitializing) {
+      await this.polySegInitializingPromise;
+      return;
+    }
+
+    if (this.polySeg?.instance) {
+      return;
+    }
+
+    this.polySegInitializing = true;
+    this.polySegInitializingPromise = new Promise((resolve) => {
+      this.polySeg = new ICRPolySeg();
+      this.polySeg
+        .initialize({
+          updateProgress: progressCallback,
+        })
+        .then(() => {
+          this.polySegInitializing = false;
+          resolve();
+        });
+    });
+
+    await this.polySegInitializingPromise;
+  },
+  /**
+   * Converts a contour to a surface using the PolySeg library.
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Array} args.polylines - The polylines representing the contour.
+   * @param {Array} args.numPointsArray - The number of points in each polyline.
+   * @param {...Function} callbacks - Optional callback functions.
+   * @returns {Promise} - A promise that resolves to the converted surface.
+   */
+  async convertContourToSurface(args, ...callbacks) {
+    const { polylines, numPointsArray } = args;
+    const [progressCallback] = callbacks;
+    await this.initializePolySeg(progressCallback);
+    const results = await this.polySeg.instance.convertContourRoiToSurface(
+      polylines,
+      numPointsArray
+    );
+
+    return results;
+  },
+  /**
+   * Converts a labelmap to a surface using the specified arguments.
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Array} args.scalarData - The scalar data of the labelmap.
+   * @param {Array} args.dimensions - The dimensions of the labelmap.
+   * @param {Array} args.spacing - The spacing of the labelmap.
+   * @param {Array} args.direction - The direction of the labelmap.
+   * @param {Array} args.origin - The origin of the labelmap.
+   * @param {number} args.segmentIndex - The segment index of the labelmap.
+   * @param {Function} progressCallback - The callback function for progress updates.
+   * @returns {Promise} - A promise that resolves with the converted surface results.
+   */
+  async convertLabelmapToSurface(args, ...callbacks) {
+    const [progressCallback] = callbacks;
+    await this.initializePolySeg(progressCallback);
+
+    const results = this.polySeg.instance.convertLabelmapToSurface(
+      args.scalarData,
+      args.dimensions,
+      args.spacing,
+      args.direction,
+      args.origin,
+      [args.segmentIndex]
+    );
+    return results;
+  },
+  /**
+   * Converts a contour to a volume labelmap.
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Array} args.segmentIndices - The indices of the segments.
+   * @param {Array} args.scalarData - The scalar data.
+   * @param {Map} args.annotationUIDsInSegmentMap - The map of annotation UIDs in segment.
+   * @param {Array} args.dimensions - The dimensions of the image data.
+   * @param {Array} args.origin - The origin of the image data.
+   * @param {Array} args.direction - The direction of the image data.
+   * @param {Array} args.spacing - The spacing of the image data.
+   * @param {...Function} callbacks - Optional callbacks.
+   * @param {Function} callbacks[0] - The progress callback.
+   * @returns {Array} - The scalar data of the segmentation voxel manager.
+   */
+  async convertContourToVolumeLabelmap(args, ...callbacks) {
+    const [progressCallback] = callbacks;
+    const polySeg = await new ICRPolySeg();
+    await polySeg.initialize({
+      updateProgress: progressCallback,
+    });
+
+    const {
+      segmentIndices,
+      scalarData,
+      annotationUIDsInSegmentMap,
+      dimensions,
+      origin,
+      direction,
+      spacing,
+    } = args;
+
+    const segmentationVoxelManager =
+      utilities.VoxelManager.createVolumeVoxelManager(dimensions, scalarData);
+
+    const imageData = vtkImageData.newInstance();
+    imageData.setDimensions(dimensions);
+    imageData.setOrigin(origin);
+    imageData.setDirection(direction);
+    imageData.setSpacing(spacing);
+
+    const scalarArray = vtkDataArray.newInstance({
+      name: 'Pixels',
+      numberOfComponents: 1,
+      values: scalarData,
+    });
+
+    imageData.getPointData().setScalars(scalarArray);
+
+    imageData.modified();
+
+    for (const index of segmentIndices) {
+      const annotations = annotationUIDsInSegmentMap.get(index);
+
+      for (const annotation of annotations) {
+        const bounds = getBoundingBoxAroundShapeWorld(
+          annotation.data.contour.polyline
+        );
+
+        const [iMin, jMin, kMin] = utilities.transformWorldToIndex(imageData, [
+          bounds[0][0],
+          bounds[1][0],
+          bounds[2][0],
+        ]);
+
+        const [iMax, jMax, kMax] = utilities.transformWorldToIndex(imageData, [
+          bounds[0][1],
+          bounds[1][1],
+          bounds[2][1],
+        ]);
+
+        // Run the pointInShapeCallback for the combined bounding box
+        pointInShapeCallback(
+          imageData,
+          (pointLPS) => {
+            // Check if the point is inside any of the polylines for this segment
+            return isPointInsidePolyline3D(
+              pointLPS,
+              annotation.data.contour.polyline
+            );
+          },
+          ({ pointIJK }) => {
+            segmentationVoxelManager.setAtIJKPoint(pointIJK, index);
+          },
+          [
+            [iMin, iMax],
+            [jMin, jMax],
+            [kMin, kMax],
+          ]
+        );
+      }
+    }
+
+    return segmentationVoxelManager.scalarData;
+  },
+  /**
+   * Converts a contour to a stack labelmap.
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Array} callbacks - Optional callbacks for progress updates.
+   * @returns {Promise<Object>} - The converted segmentations information.
+   */
+  async convertContourToStackLabelmap(args, ...callbacks) {
+    const [progressCallback] = callbacks;
+    const polySeg = await new ICRPolySeg();
+    await polySeg.initialize({
+      updateProgress: progressCallback,
+    });
+
+    const { segmentationsInfo, annotationUIDsInSegmentMap, segmentIndices } =
+      args;
+
+    const segmentationVoxelManagers = new Map();
+
+    segmentationsInfo.forEach((segmentationInfo, referencedImageId) => {
+      const { dimensions, scalarData, direction, spacing, origin } =
+        segmentationInfo;
+      const manager = utilities.VoxelManager.createVolumeVoxelManager(
+        dimensions,
+        scalarData
+      );
+
+      const imageData = vtkImageData.newInstance();
+      imageData.setDimensions(dimensions);
+      imageData.setOrigin(origin);
+      imageData.setDirection(direction);
+      imageData.setSpacing(spacing);
+
+      const scalarArray = vtkDataArray.newInstance({
+        name: 'Pixels',
+        numberOfComponents: 1,
+        values: scalarData,
+      });
+
+      imageData.getPointData().setScalars(scalarArray);
+
+      imageData.modified();
+
+      segmentationVoxelManagers.set(referencedImageId, { manager, imageData });
+    });
+
+    for (const index of segmentIndices) {
+      const annotations = annotationUIDsInSegmentMap.get(index);
+
+      for (const annotation of annotations) {
+        if (!annotation?.data) {
+          continue;
+        }
+        const bounds = getBoundingBoxAroundShapeWorld(
+          annotation.data.contour.polyline
+        );
+
+        const { referencedImageId } = annotation.metadata;
+
+        const { manager: segmentationVoxelManager, imageData } =
+          segmentationVoxelManagers.get(referencedImageId);
+
+        const [iMin, jMin, kMin] = utilities.transformWorldToIndex(imageData, [
+          bounds[0][0],
+          bounds[1][0],
+          bounds[2][0],
+        ]);
+
+        const [iMax, jMax, kMax] = utilities.transformWorldToIndex(imageData, [
+          bounds[0][1],
+          bounds[1][1],
+          bounds[2][1],
+        ]);
+
+        // Run the pointInShapeCallback for the combined bounding box
+        pointInShapeCallback(
+          imageData,
+          (pointLPS) => {
+            // Check if the point is inside any of the polylines for this segment
+            return isPointInsidePolyline3D(
+              pointLPS,
+              annotation.data.contour.polyline
+            );
+          },
+          ({ pointIJK }) => {
+            segmentationVoxelManager.setAtIJKPoint(pointIJK, index);
+          },
+          [
+            [iMin, iMax],
+            [jMin, jMax],
+            [kMin, kMax],
+          ]
+        );
+      }
+    }
+
+    segmentationsInfo.forEach((segmentationInfo, referencedImageId) => {
+      const { manager: segmentationVoxelManager } =
+        segmentationVoxelManagers.get(referencedImageId);
+
+      segmentationInfo.scalarData = segmentationVoxelManager.scalarData;
+    });
+    return segmentationsInfo;
+  },
+  /**
+   * Converts a surface to a volume labelmap.
+   *
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Array} args.points - The points defining the surface.
+   * @param {Array} args.polys - The polygons defining the surface.
+   * @param {Array} args.dimensions - The dimensions of the volume.
+   * @param {Array} args.spacing - The spacing between voxels in the volume.
+   * @param {Array} args.direction - The direction of the volume.
+   * @param {Array} args.origin - The origin of the volume.
+   * @param {Function} progressCallback - The callback function for reporting progress.
+   * @returns {Promise} - A promise that resolves with the converted labelmap.
+   */
+  async convertSurfaceToVolumeLabelmap(args, ...callbacks) {
+    const [progressCallback] = callbacks;
+    await this.initializePolySeg(progressCallback);
+
+    const results = this.polySeg.instance.convertSurfaceToLabelmap(
+      args.points,
+      args.polys,
+      args.dimensions,
+      args.spacing,
+      args.direction,
+      args.origin
+    );
+
+    return results;
+  },
+  /**
+   * Converts surfaces to a volume labelmap.
+   * @param {Object} args - The arguments for the conversion.
+   * @param {Map} args.segmentsInfo - A map containing information about the segments.
+   * @param {Function} progressCallback - A callback function for reporting progress.
+   * @returns {Uint8Array} - The resulting volume labelmap.
+   */
+  async convertSurfacesToVolumeLabelmap(args, ...callbacks) {
+    const [progressCallback] = callbacks;
+    await this.initializePolySeg(progressCallback);
+
+    const { segmentsInfo } = args;
+
+    const promises = Array.from(segmentsInfo.keys()).map((segmentIndex) => {
+      const { points, polys } = segmentsInfo.get(segmentIndex);
+      const result = this.polySeg.instance.convertSurfaceToLabelmap(
+        points,
+        polys,
+        args.dimensions,
+        args.spacing,
+        args.direction,
+        args.origin
+      );
+
+      return {
+        ...result,
+        segmentIndex,
+      };
+    });
+
+    const results = await Promise.all(promises);
+
+    const targetImageData = vtkImageData.newInstance();
+    targetImageData.setDimensions(args.dimensions);
+    targetImageData.setOrigin(args.origin);
+    targetImageData.setSpacing(args.spacing);
+    targetImageData.setDirection(args.direction);
+
+    const totalSize =
+      args.dimensions[0] * args.dimensions[1] * args.dimensions[2];
+
+    const scalarArray = vtkDataArray.newInstance({
+      name: 'Pixels',
+      numberOfComponents: 1,
+      values: new Uint8Array(totalSize),
+    });
+
+    targetImageData.getPointData().setScalars(scalarArray);
+    targetImageData.modified();
+
+    // we need to then consolidate the results into a single volume
+    // by looping into each voxel with pointInShapeCallback
+    // and check if the voxel is inside any of the reconstructed
+    // labelmaps
+
+    const segmentationVoxelManager =
+      utilities.VoxelManager.createVolumeVoxelManager(
+        args.dimensions,
+        targetImageData.getPointData().getScalars().getData()
+      );
+
+    const outputVolumesInfo = results.map((result) => {
+      const { data, dimensions, direction, origin, spacing } = result;
+      const volume = vtkImageData.newInstance();
+      volume.setDimensions(dimensions);
+      volume.setOrigin(origin);
+      volume.setSpacing(spacing);
+      volume.setDirection(direction);
+
+      const scalarArray = vtkDataArray.newInstance({
+        name: 'Pixels',
+        numberOfComponents: 1,
+        values: data,
+      });
+
+      volume.getPointData().setScalars(scalarArray);
+
+      volume.modified();
+
+      const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
+        dimensions,
+        data
+      );
+
+      const extent = volume.getExtent(); // e.g., [0, 176, 0, 268, 0, 337] for dimensions of [177, 269, 338]
+
+      return {
+        volume,
+        voxelManager,
+        extent,
+        scalarData: data,
+        segmentIndex: result.segmentIndex,
+      };
+    });
+
+    pointInShapeCallback(
+      targetImageData,
+      () => true, // we want to loop into all voxels
+      ({ pointIJK, pointLPS }) => {
+        // Check if the point is inside any of the reconstructed labelmaps
+        // Todo: we can optimize this by returning early if the bounding box
+        // of the point is outside the bounding box of the labelmap
+
+        try {
+          for (const volumeInfo of outputVolumesInfo) {
+            const { volume, extent, voxelManager, segmentIndex } = volumeInfo;
+
+            const index = volume.worldToIndex(pointLPS);
+
+            // check if the ijk point is inside the volume
+            if (
+              index[0] < extent[0] ||
+              index[0] > extent[1] ||
+              index[1] < extent[2] ||
+              index[1] > extent[3] ||
+              index[2] < extent[4] ||
+              index[2] > extent[5]
+            ) {
+              continue;
+            }
+
+            const roundedIndex = index.map(Math.round);
+            const value = voxelManager.getAtIJK(...roundedIndex);
+            if (value > 0) {
+              segmentationVoxelManager.setAtIJKPoint(pointIJK, segmentIndex);
+              break;
+            }
+          }
+        } catch (error) {
+          // right now there is weird error if the point is outside the volume
+        }
+      }
+    );
+
+    return segmentationVoxelManager.scalarData;
+  },
+};
+
+expose(polySegConverters);

package/dist/cjs/tools/displayTools/Contour/addContourSetsToElement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"addContourSetsToElement.js","sourceRoot":"","sources":["../../../../../src/tools/displayTools/Contour/addContourSetsToElement.ts"],"names":[],"mappings":"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"}

package/dist/cjs/tools/displayTools/Contour/addOrUpdateContourSets.d.ts

@@ -1,3 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificContourRepresentation } from '../../../types';
-export declare function addOrUpdateContourSets(viewport: Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;