@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.28

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -1,74 +1,33 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { utilities } from '@cornerstonejs/core';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { addColorLUT } from './addColorLUT';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
-import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
-import { addSegmentationRepresentationState } from './addSegmentationRepresentationState';
-function getLabelmapSegmentationRepresentationRenderingConfig() {
-    const cfun = vtkColorTransferFunction.newInstance();
-    const ofun = vtkPiecewiseFunction.newInstance();
-    ofun.addPoint(0, 0);
-    return {
-        ofun,
-        cfun,
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getColorLUT } from './getColorLUT';
+function internalAddSegmentationRepresentation(viewportId, representationInput) {
+    const { segmentationId, config } = representationInput;
+    const renderingConfig = {
+        colorLUTIndex: getColorLUTIndex(config),
     };
-}
-async function internalAddSegmentationRepresentation(viewportId, representationInput) {
-    const { segmentationId, options = {} } = representationInput;
-    const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
-        utilities.uuidv4();
-    const colorLUTIndexToUse = getColorLUTIndex(options);
-    const { type } = representationInput;
-    let renderingConfig;
-    if (type === SegmentationRepresentations.Labelmap) {
-        renderingConfig = getLabelmapSegmentationRepresentationRenderingConfig();
-    }
-    else {
-        renderingConfig = {};
-    }
-    const representation = {
-        segmentationId,
-        segmentationRepresentationUID,
-        type: representationInput.type,
-        colorLUTIndex: colorLUTIndexToUse,
-        rendering: renderingConfig,
-        polySeg: options.polySeg,
-        config: {
-            allSegments: {},
-            perSegment: {},
-        },
-    };
-    addSegmentationRepresentationState(viewportId, representation);
-    const initialConfig = representationInput.config;
-    if (initialConfig) {
-        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig);
-    }
+    defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
     }
     triggerSegmentationModified(segmentationId);
-    return segmentationRepresentationUID;
 }
-function getColorLUTIndex(options = {}) {
-    const colorLUTOrIndexInput = options.colorLUTOrIndex;
-    let colorLUTIndexToUse;
-    if (typeof colorLUTOrIndexInput === 'number') {
-        colorLUTIndexToUse = colorLUTOrIndexInput;
-    }
-    else {
-        const nextIndex = getNextColorLUTIndex();
-        const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
-            ? colorLUTOrIndexInput
-            : CORNERSTONE_COLOR_LUT;
-        addColorLUT(colorLUTToAdd, nextIndex);
-        colorLUTIndexToUse = nextIndex;
+function getColorLUTIndex(config) {
+    const colorLUT = config?.colorLUT;
+    const nextIndex = getNextColorLUTIndex();
+    const colorLUTToAdd = Array.isArray(colorLUT)
+        ? colorLUT
+        : CORNERSTONE_COLOR_LUT;
+    addColorLUT(colorLUTToAdd, nextIndex);
+    const colorLUTIndex = nextIndex;
+    if (!getColorLUT(colorLUTIndex)) {
+        throw new Error(`Color LUT with index ${colorLUTIndex} not found`);
     }
-    return colorLUTIndexToUse;
+    return colorLUTIndex;
 }
 export { internalAddSegmentationRepresentation };
-//# sourceMappingURL=internalAddSegmentationRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.js

@@ -4,4 +4,3 @@ import { computeContourData } from './contourComputationStrategies';
 export function computeAndAddContourRepresentation(segmentationId, options = {}) {
     return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Contour, () => computeContourData(segmentationId, options), () => undefined);
 }
-//# sourceMappingURL=computeAndAddContourRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.js

@@ -5,7 +5,8 @@ import { clipAndCacheSurfacesForViewport } from '../../helpers/clipAndCacheSurfa
 import { extractContourData } from './utils/extractContourData';
 import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
 import { getSegmentation } from '../../getSegmentation';
-import { setSegmentationRepresentationConfig } from '../../setSegmentationRepresentationConfig';
+import { segmentationStyle } from '../../SegmentationStyle';
+import { SegmentationRepresentations } from '../../../../enums';
 export async function computeContourData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -34,12 +35,10 @@ export async function computeContourData(segmentationId, options = {}) {
     if (!rawContourData) {
         throw new Error('Not enough data to convert to contour, currently only support converting volume labelmap to contour if available');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    setSegmentationRepresentationConfig(segmentationRepresentationUID, {
-        Contour: {
-            fillAlpha: 0,
-        },
+    segmentationStyle.setSegmentationSpecificStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
+        fillAlpha: 0,
     });
     return {
         annotationUIDsMap,
@@ -54,7 +53,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
         console.error('Failed to convert labelmap to surface or labelmap is empty');
         return;
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const pointsAndPolys = results.map((surface) => {
         return {
             id: surface.segmentIndex.toString(),
@@ -63,7 +62,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
             segmentIndex: surface.segmentIndex,
         };
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationRepresentationUID);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationId);
     const rawResults = extractContourData(polyDataCache);
     return rawResults;
 }
@@ -71,7 +70,7 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     if (!options.viewport) {
         throw new Error('Viewport is required to compute contour from surface');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
@@ -96,9 +95,8 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
         surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationId);
     const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
     return rawResults;
 }
 export { computeContourFromLabelmapSegmentation };
-//# sourceMappingURL=contourComputationStrategies.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js

@@ -69,4 +69,3 @@ const _extractLineSegments = (contourData) => {
     }
     return { lineSegments, linesNumberOfPoints };
 };
-//# sourceMappingURL=createAndAddContourSegmentationsFromClippedSurfaces.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.js

@@ -1,15 +1,18 @@
 export function extractContourData(polyDataCache, segmentIndexMap) {
     const rawResults = new Map();
     for (const [cacheId, intersectionInfo] of polyDataCache) {
-        const surfaceId = cacheId.split('_')[1];
+        let segmentIndex;
+        const surfaceId = cacheId.split('-')[1];
+        if (!segmentIndexMap) {
+            segmentIndex = Number(surfaceId.split('_')[1]);
+        }
+        else {
+            segmentIndex = segmentIndexMap.get(surfaceId.split('_')[1]);
+        }
         for (const [_, result] of intersectionInfo) {
             if (!result) {
                 continue;
             }
-            const segmentIndex = Number(surfaceId) || segmentIndexMap?.get(surfaceId);
-            if (!segmentIndex) {
-                continue;
-            }
             if (!rawResults.has(segmentIndex)) {
                 rawResults.set(segmentIndex, []);
             }
@@ -18,4 +21,3 @@ export function extractContourData(polyDataCache, segmentIndexMap) {
     }
     return rawResults;
 }
-//# sourceMappingURL=extractContourData.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.js

@@ -23,4 +23,3 @@ export function updateContoursOnCameraModified(surfacesInfo, viewport, segmentat
     viewport.element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraModifiedCallback);
     viewport.element.addEventListener(Enums.Events.CAMERA_MODIFIED);
 }
-//# sourceMappingURL=updateContoursOnCameraModified.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.js

@@ -1,7 +1,13 @@
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
 import { computeLabelmapData } from './labelmapComputationStrategies';
-export function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
-    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => undefined);
+import { defaultSegmentationStateManager } from '../../SegmentationStateManager';
+import { triggerSegmentationDataModified } from '../../triggerSegmentationEvents';
+export async function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
+    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => null, () => {
+        defaultSegmentationStateManager.processLabelmapRepresentationAddition(options.viewport.id, segmentationId);
+        setTimeout(() => {
+            triggerSegmentationDataModified(segmentationId);
+        }, 0);
+    });
 }
-//# sourceMappingURL=computeAndAddLabelmapRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.js

@@ -17,7 +17,7 @@ export async function convertContourToVolumeLabelmap(contourRepresentationData,
         throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
     }
     const segmentationVolumeId = utilities.uuidv4();
-    const segmentationVolume = volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId, {
+    const segmentationVolume = volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
         volumeId: segmentationVolumeId,
     });
     const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
@@ -59,7 +59,7 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             throw new Error('ImageIds must be cached before converting contour to labelmap');
         }
     });
-    const segImages = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const segImages = await imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
     const segmentationImageIds = segImages.map((it) => it.imageId);
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     const segmentationsInfo = new Map();
@@ -141,4 +141,3 @@ function _getAnnotationMapFromSegmentation(contourRepresentationData, options =
     });
     return { segmentIndices, annotationUIDsInSegmentMap };
 }
-//# sourceMappingURL=convertContourToLabelmap.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertSurfaceToLabelmap.js

@@ -47,4 +47,3 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
 }
 export async function convertSurfaceToStackLabelmap() {
 }
-//# sourceMappingURL=convertSurfaceToLabelmap.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -3,7 +3,7 @@ import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getU
 import { getSegmentation } from '../../getSegmentation';
 import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
 import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
-import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
+import { computeStackLabelmapFromVolume } from '../../helpers/computeStackLabelmapFromVolume';
 export async function computeLabelmapData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -49,7 +49,6 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
         : convertContourToStackLabelmap;
     const result = await convertFunction(representationData, {
         segmentIndices,
-        segmentationRepresentationUID: options.segmentationRepresentationUID,
         viewport: options.viewport,
     });
     return result;
@@ -74,12 +73,11 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     let segmentationVolume;
     if (isVolume) {
         const volumeId = viewport.getVolumeId();
-        segmentationVolume =
-            await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId);
+        segmentationVolume = await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();
-        const segImages = imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+        const segImages = imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
         const segImageIds = segImages.map((image) => image.imageId);
         segmentationVolume = await volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
     }
@@ -87,10 +85,9 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     if (isVolume) {
         return result;
     }
-    const stackData = (await computeStackSegmentationFromVolume({
+    const stackData = (await computeStackLabelmapFromVolume({
         volumeId: segmentationVolume.volumeId,
     }));
     return stackData;
 }
 export { computeLabelmapFromContourSegmentation };
-//# sourceMappingURL=labelmapComputationStrategies.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation.js

@@ -5,4 +5,3 @@ import { updateSurfaceData } from './updateSurfaceData';
 export function computeAndAddSurfaceRepresentation(segmentationId, options = {}) {
     return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Surface, () => computeSurfaceData(segmentationId, options), () => updateSurfaceData(segmentationId));
 }
-//# sourceMappingURL=computeAndAddSurfaceRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertContourToSurface.js

@@ -35,4 +35,3 @@ export async function convertContourToSurface(contourRepresentationData, segment
     triggerWorkerProgress(eventTarget, 1);
     return results;
 }
-//# sourceMappingURL=convertContourToSurface.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
-export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number, isVolume?: boolean): Promise<Types.SurfaceData>;
+export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.js

@@ -1,5 +1,5 @@
 import { cache, eventTarget, getWebWorkerManager, triggerEvent, Enums, } from '@cornerstonejs/core';
-import { computeVolumeSegmentationFromStack } from '../../SegmentationStateManager';
+import { computeVolumeLabelmapFromStack } from '../../helpers/computeVolumeLabelmapFromStack';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
 const triggerWorkerProgress = (eventTarget, progress) => {
@@ -8,15 +8,15 @@ const triggerWorkerProgress = (eventTarget, progress) => {
         type: WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
     });
 };
-export async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex, isVolume = true) {
+export async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex) {
     let volumeId;
-    if (isVolume) {
+    if (labelmapRepresentationData.volumeId) {
         volumeId = labelmapRepresentationData
             .volumeId;
     }
     else {
         const { imageIds } = labelmapRepresentationData;
-        ({ volumeId } = await computeVolumeSegmentationFromStack({
+        ({ volumeId } = await computeVolumeLabelmapFromStack({
             imageIds,
         }));
     }
@@ -41,4 +41,3 @@ export async function convertLabelmapToSurface(labelmapRepresentationData, segme
     triggerWorkerProgress(eventTarget, 1);
     return results;
 }
-//# sourceMappingURL=convertLabelmapToSurface.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.js

@@ -1,19 +1,13 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
 import { getSegmentIndexColor } from '../../config/segmentationColor';
-import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
 import { getSegmentation } from '../../getSegmentation';
 export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
-    let segmentationRepresentation;
-    if (options.segmentationRepresentationUID) {
-        segmentationRepresentation = getSegmentationRepresentation(options.segmentationRepresentationUID);
-    }
     const segmentation = getSegmentation(segmentationId);
     const geometryIds = new Map();
     const promises = Object.keys(rawSurfacesData).map(async (index) => {
         const rawSurfaceData = rawSurfacesData[index];
         const segmentIndex = rawSurfaceData.segmentIndex;
-        const color = segmentationRepresentation;
-        getSegmentIndexColor(segmentationRepresentation.segmentationRepresentationUID, segmentIndex).slice(0, 3);
+        const color = getSegmentIndexColor(options.viewport.id, segmentation.segmentationId, segmentIndex).slice(0, 3);
         if (!color) {
             throw new Error('No color found for segment index, unable to create surface');
         }
@@ -38,4 +32,3 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
         geometryIds,
     };
 }
-//# sourceMappingURL=createAndCacheSurfacesFromRaw.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.js

@@ -2,7 +2,6 @@ import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getU
 import { getSegmentation } from '../../getSegmentation';
 import { convertContourToSurface } from './convertContourToSurface';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
-import { isVolumeSegmentation } from '../../../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { convertLabelmapToSurface } from './convertLabelmapToSurface';
 export async function computeSurfaceData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
@@ -41,11 +40,10 @@ async function computeSurfaceFromLabelmapSegmentation(segmentationId, options =
         console.warn('Only support surface update from labelmaps');
         return;
     }
-    const isVolume = isVolumeSegmentation(segmentation.representationData.Labelmap);
     const labelmapRepresentationData = segmentation.representationData.Labelmap;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map((index) => {
-        const surface = convertLabelmapToSurface(labelmapRepresentationData, index, isVolume);
+        const surface = convertLabelmapToSurface(labelmapRepresentationData, index);
         return surface;
     });
     const surfaces = await Promise.allSettled(promises);
@@ -75,4 +73,3 @@ async function computeSurfaceFromContourSegmentation(segmentationId, options = {
     return surfaces;
 }
 export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };
-//# sourceMappingURL=surfaceComputationStrategies.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.js

@@ -1,7 +1,9 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { getSegmentation, getSegmentationRepresentations, getViewportIdsWithSegmentation, } from '../../segmentationState';
+import { getViewportIdsWithSegmentation } from '../../getViewportIdsWithSegmentation';
+import { getSegmentation } from '../../getSegmentation';
 import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
+import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
@@ -29,15 +31,14 @@ export async function updateSurfaceData(segmentationId) {
         if (!geometry) {
             const viewportIds = getViewportIdsWithSegmentation(segmentationId);
             return viewportIds.map((viewportId) => {
-                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
-                return segmentationRepresentations.map((segmentationRepresentation) => {
-                    if (segmentationRepresentation.type !==
-                        SegmentationRepresentations.Surface) {
-                        return;
-                    }
+                const surfaceRepresentation = getSegmentationRepresentation(viewportId, {
+                    segmentationId,
+                    type: SegmentationRepresentations.Surface,
+                });
+                return [surfaceRepresentation].map((surfaceRepresentation) => {
                     segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
                     return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
-                        segmentationRepresentationUID: segmentationRepresentation.segmentationRepresentationUID,
+                        segmentationId: surfaceRepresentation.segmentationId,
                     });
                 });
             });
@@ -56,4 +57,3 @@ export async function updateSurfaceData(segmentationId) {
     await Promise.all(promises);
     triggerSegmentationModified(segmentationId);
 }
-//# sourceMappingURL=updateSurfaceData.js.map

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.d.ts

@@ -1,2 +1,3 @@
-declare function canComputeRequestedRepresentation(segmentationRepresentationUID: string): boolean;
+import { SegmentationRepresentations } from '../../../enums';
+declare function canComputeRequestedRepresentation(segmentationId: string, type: SegmentationRepresentations): boolean;
 export { canComputeRequestedRepresentation };

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.js

@@ -1,6 +1,5 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { getSegmentation } from '../getSegmentation';
-import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
 import { validate as validateLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 const conversionPaths = new Map([
     [
@@ -22,15 +21,10 @@ const conversionPaths = new Map([
         new Set([SegmentationRepresentations.Labelmap]),
     ],
 ]);
-function canComputeRequestedRepresentation(segmentationRepresentationUID) {
-    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    const { type: representationType, polySeg } = segmentationRepresentation;
-    if (!polySeg || !polySeg.enabled) {
-        return false;
-    }
-    const { representationData } = getSegmentation(segmentationRepresentation.segmentationId);
+function canComputeRequestedRepresentation(segmentationId, type) {
+    const { representationData } = getSegmentation(segmentationId);
     const existingRepresentationTypes = getExistingRepresentationTypes(representationData);
-    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, representationType));
+    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, type));
 }
 function getExistingRepresentationTypes(representationData) {
     const supportedTypes = [];
@@ -62,4 +56,3 @@ async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
         false);
 }
 export { canComputeRequestedRepresentation };
-//# sourceMappingURL=canComputeRequestedRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.d.ts

@@ -1,3 +1,3 @@
 import type { SegmentationRepresentations } from '../../../enums';
-declare function computeAndAddRepresentation<T>(segmentationId: string, representationType: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void): Promise<T>;
+declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void, onComputationComplete?: () => void): Promise<T>;
 export { computeAndAddRepresentation };

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.js

@@ -1,24 +1,26 @@
 import { eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../../enums';
-import addRepresentationData from '../addRepresentationData';
+import addRepresentationData from '../internalAddRepresentationData';
 import { triggerSegmentationModified } from '../triggerSegmentationEvents';
 import debounce from '../../../utilities/debounce';
 import { registerPolySegWorker } from './registerPolySegWorker';
+import { defaultSegmentationStateManager } from '../SegmentationStateManager';
 const computedRepresentations = new Map();
-async function computeAndAddRepresentation(segmentationId, representationType, computeFunction, updateFunction) {
+async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
     registerPolySegWorker();
     const data = await computeFunction();
     addRepresentationData({
         segmentationId,
-        type: representationType,
+        type,
         data,
     });
+    onComputationComplete?.();
     if (!computedRepresentations.has(segmentationId)) {
         computedRepresentations.set(segmentationId, []);
     }
     const representations = computedRepresentations.get(segmentationId);
-    if (!representations.includes(representationType)) {
-        representations.push(representationType);
+    if (!representations.includes(type)) {
+        representations.push(type);
     }
     subscribeToSegmentationChanges(updateFunction);
     triggerSegmentationModified(segmentationId);
@@ -44,4 +46,3 @@ const _debouncedSegmentationModified = debounce((event, updateFunction) => {
     }
 }, 300);
 export { computeAndAddRepresentation };
-//# sourceMappingURL=computeAndAddRepresentation.js.map

package/dist/esm/stateManagement/segmentation/polySeg/index.js

@@ -3,4 +3,3 @@ import { computeAndAddLabelmapRepresentation } from './Labelmap/computeAndAddLab
 import { computeAndAddContourRepresentation } from './Contour/computeAndAddContourRepresentation';
 import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
 export { canComputeRequestedRepresentation, computeAndAddSurfaceRepresentation, computeAndAddLabelmapRepresentation, computeAndAddContourRepresentation, };
-//# sourceMappingURL=index.js.map

package/dist/esm/stateManagement/segmentation/polySeg/registerPolySegWorker.js

@@ -21,4 +21,3 @@ export function registerPolySegWorker() {
     };
     workerManager.registerWorker('polySeg', workerFn, options);
 }
-//# sourceMappingURL=registerPolySegWorker.js.map

package/dist/esm/stateManagement/segmentation/removeColorLUT.js

@@ -3,4 +3,3 @@ export function removeColorLUT(colorLUTIndex) {
     const segmentationStateManager = defaultSegmentationStateManager;
     segmentationStateManager.removeColorLUT(colorLUTIndex);
 }
-//# sourceMappingURL=removeColorLUT.js.map

package/dist/esm/stateManagement/segmentation/removeSegmentation.js

@@ -5,4 +5,3 @@ export function removeSegmentation(segmentationId) {
     segmentationStateManager.removeSegmentation(segmentationId);
     triggerSegmentationRemoved(segmentationId);
 }
-//# sourceMappingURL=removeSegmentation.js.map

package/dist/esm/stateManagement/segmentation/removeSegmentationRepresentations.d.ts

@@ -1,2 +1,14 @@
-declare function removeSegmentationRepresentations(viewportId: string, segmentationRepresentationUIDs?: string[] | undefined, immediate?: boolean): void;
-export default removeSegmentationRepresentations;
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+declare function removeSegmentationRepresentation(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}, immediate?: boolean): void;
+declare function removeSegmentationRepresentations(viewportId: string, specifier: {
+    segmentationId: string;
+    type?: SegmentationRepresentations;
+}, immediate?: boolean): void;
+declare function removeAllSegmentationRepresentations(): void;
+declare function removeLabelmapRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+declare function removeContourRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+declare function removeSurfaceRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+export { removeSegmentationRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, };