@cornerstonejs/tools 2.0.0-beta.7 → 2.0.0

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertSurfaceToLabelmap.d.ts

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SurfaceSegmentationData } from '../../../../types/SurfaceTypes';
+export declare function convertSurfaceToVolumeLabelmap(surfaceRepresentationData: SurfaceSegmentationData, segmentationVolume: Types.IImageVolume): Promise<{
+    volumeId: string;
+}>;
+export declare function convertSurfaceToStackLabelmap(): Promise<void>;

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

@@ -16,14 +16,14 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
     geometryIds.forEach((geometryId, segmentIndex) => {
         const geometry = cache.getGeometry(geometryId);
         const geometryData = geometry.data;
-        const points = geometryData.getPoints();
-        const polys = geometryData.getPolys();
+        const points = geometryData.points;
+        const polys = geometryData.polys;
         segmentsInfo.set(segmentIndex, {
             points,
             polys,
         });
     });
-    const { dimensions, direction, origin, spacing } = segmentationVolume;
+    const { dimensions, direction, origin, spacing, voxelManager } = segmentationVolume;
     triggerWorkerProgress(eventTarget, 0);
     const newScalarData = await workerManager.executeTask('polySeg', 'convertSurfacesToVolumeLabelmap', {
         segmentsInfo,
@@ -38,12 +38,8 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
             },
         ],
     });
-    triggerWorkerProgress(eventTarget, 1);
-    segmentationVolume.imageData
-        .getPointData()
-        .getScalars()
-        .setData(newScalarData);
-    segmentationVolume.imageData.modified();
+    triggerWorkerProgress(eventTarget, 100);
+    voxelManager.setCompleteScalarDataArray(newScalarData);
     segmentationVolume.modified();
     return {
         volumeId: segmentationVolume.volumeId,
@@ -51,4 +47,3 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
 }
 export async function convertSurfaceToStackLabelmap() {
 }
-//# sourceMappingURL=convertSurfaceToLabelmap.js.map

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.d.ts

@@ -0,0 +1,6 @@
+import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
+import type { PolySegConversionOptions } from '../../../../types';
+export type RawLabelmapData = LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack;
+export declare function computeLabelmapData(segmentationId: string, options?: PolySegConversionOptions): Promise<RawLabelmapData>;
+declare function computeLabelmapFromContourSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack>;
+export { computeLabelmapFromContourSegmentation };

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

@@ -1,9 +1,9 @@
-import { VolumeViewport, volumeLoader, utilities } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation } from '../../segmentationState';
+import { VolumeViewport, volumeLoader, imageLoader } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+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
@@ -12,13 +12,13 @@ export async function computeLabelmapData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.CONTOUR) {
+        if (representationData.Contour) {
             rawLabelmapData = await computeLabelmapFromContourSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.SURFACE) {
+        else if (representationData.Surface) {
             rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(segmentation.segmentationId, {
                 segmentIndices,
                 ...options,
@@ -43,59 +43,51 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
     const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData.CONTOUR;
+    const representationData = segmentation.representationData.Contour;
     const convertFunction = isVolume
         ? convertContourToVolumeLabelmap
         : convertContourToStackLabelmap;
     const result = await convertFunction(representationData, {
         segmentIndices,
-        segmentationRepresentationUID: options.segmentationRepresentationUID,
         viewport: options.viewport,
     });
     return result;
 }
 async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
-    const isVolume = options.viewport instanceof VolumeViewport ?? true;
+    const { viewport } = options;
+    const isVolume = viewport instanceof VolumeViewport ?? true;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
     const segmentation = getSegmentation(segmentationId);
     const segmentsGeometryIds = new Map();
-    const representationData = segmentation.representationData.SURFACE;
+    const representationData = segmentation.representationData.Surface;
     representationData.geometryIds.forEach((geometryId, segmentIndex) => {
         if (segmentIndices.includes(segmentIndex)) {
             segmentsGeometryIds.set(segmentIndex, geometryId);
         }
     });
-    if (isVolume && !options.viewport) {
+    if (isVolume && !viewport) {
         throw new Error('Cannot compute labelmap from surface segmentation without providing the viewport');
     }
     let segmentationVolume;
     if (isVolume) {
-        const defaultActor = options.viewport.getDefaultActor();
-        const { uid: volumeId } = defaultActor;
-        segmentationVolume =
-            await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId);
+        const volumeId = viewport.getVolumeId();
+        segmentationVolume = await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();
-        const volumeId = 'generatedSegmentationVolumeId';
-        const volumeProps = utilities.generateVolumePropsFromImageIds(imageIds, volumeId);
-        delete volumeProps.imageIds;
-        segmentationVolume = await volumeLoader.createLocalSegmentationVolume({
-            ...volumeProps,
-            scalarData: volumeProps.scalarData,
-            referencedImageIds: imageIds,
-        }, volumeId);
+        const segImages = imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
+        const segImageIds = segImages.map((image) => image.imageId);
+        segmentationVolume = await volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
     }
     const result = await convertSurfaceToVolumeLabelmap({ geometryIds: segmentsGeometryIds }, segmentationVolume);
     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.d.ts

@@ -0,0 +1,4 @@
+import type { PolySegConversionOptions } from '../../../../types';
+export declare function computeAndAddSurfaceRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    geometryIds: Map<number, string>;
+}>;

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.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationData } from '../../../../types';
+export declare function convertContourToSurface(contourRepresentationData: ContourSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

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

@@ -1,12 +1,12 @@
-import { Enums, eventTarget, triggerEvent } from '@cornerstonejs/core';
-import { getWebWorkerManager } from '@cornerstonejs/core';
+import { Enums, eventTarget, triggerEvent, getWebWorkerManager, } from '@cornerstonejs/core';
 import { getAnnotation } from '../../../annotation/annotationState';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
-const triggerWorkerProgress = (eventTarget, progress) => {
+const triggerWorkerProgress = (eventTarget, progress, id) => {
     triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
         progress,
         type: WorkerTypes.POLYSEG_CONTOUR_TO_SURFACE,
+        id,
     });
 };
 export async function convertContourToSurface(contourRepresentationData, segmentIndex) {
@@ -16,22 +16,22 @@ export async function convertContourToSurface(contourRepresentationData, segment
     const annotationUIDs = annotationUIDsMap.get(segmentIndex);
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
-        const { polyline } = annotation.data.contour;
+        const { polyline } = annotation.data
+            .contour;
         numPointsArray.push(polyline.length);
         polyline.forEach((polyline) => polylines.push(...polyline));
     }
-    triggerWorkerProgress(eventTarget, 0);
+    triggerWorkerProgress(eventTarget, 0, segmentIndex);
     const results = await workerManager.executeTask('polySeg', 'convertContourToSurface', {
         polylines,
         numPointsArray,
     }, {
         callbacks: [
             (progress) => {
-                triggerWorkerProgress(eventTarget, progress);
+                triggerWorkerProgress(eventTarget, progress, segmentIndex);
             },
         ],
     });
-    triggerWorkerProgress(eventTarget, 1);
+    triggerWorkerProgress(eventTarget, 100, segmentIndex);
     return results;
 }
-//# sourceMappingURL=convertContourToSurface.js.map

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

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

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

@@ -1,30 +1,30 @@
-import { cache, eventTarget, triggerEvent, Enums, } from '@cornerstonejs/core';
-import { getWebWorkerManager } from '@cornerstonejs/core';
-import { computeVolumeSegmentationFromStack } from '../../convertStackToVolumeSegmentation';
+import { cache, eventTarget, getWebWorkerManager, triggerEvent, Enums, } from '@cornerstonejs/core';
+import { computeVolumeLabelmapFromStack } from '../../helpers/computeVolumeLabelmapFromStack';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
-const triggerWorkerProgress = (eventTarget, progress) => {
+const triggerWorkerProgress = (eventTarget, progress, id) => {
     triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
         progress,
         type: WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
+        id,
     });
 };
-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 { imageIdReferenceMap } = labelmapRepresentationData;
-        ({ volumeId } = await computeVolumeSegmentationFromStack({
-            imageIdReferenceMap,
+        const { imageIds } = labelmapRepresentationData;
+        ({ volumeId } = await computeVolumeLabelmapFromStack({
+            imageIds,
         }));
     }
     const volume = cache.getVolume(volumeId);
-    const scalarData = volume.getScalarData();
+    const scalarData = volume.voxelManager.getCompleteScalarDataArray();
     const { dimensions, spacing, origin, direction } = volume;
-    triggerWorkerProgress(eventTarget, 0);
+    triggerWorkerProgress(eventTarget, 0, segmentIndex);
     const results = await workerManager.executeTask('polySeg', 'convertLabelmapToSurface', {
         scalarData,
         dimensions,
@@ -35,11 +35,10 @@ export async function convertLabelmapToSurface(labelmapRepresentationData, segme
     }, {
         callbacks: [
             (progress) => {
-                triggerWorkerProgress(eventTarget, progress);
+                triggerWorkerProgress(eventTarget, progress, segmentIndex);
             },
         ],
     });
-    triggerWorkerProgress(eventTarget, 1);
+    triggerWorkerProgress(eventTarget, 100, segmentIndex);
     return results;
 }
-//# sourceMappingURL=convertLabelmapToSurface.js.map

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

@@ -0,0 +1,5 @@
+import type { RawSurfacesData } from './surfaceComputationStrategies';
+import type { PolySegConversionOptions } from '../../../../types';
+export declare function createAndCacheSurfacesFromRaw(segmentationId: string, rawSurfacesData: RawSurfacesData, options?: PolySegConversionOptions): Promise<{
+    geometryIds: Map<number, string>;
+}>;

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

@@ -1,19 +1,13 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
-import { getColorForSegmentIndex } from '../../config/segmentationColor';
-import { findSegmentationRepresentationByUID, getSegmentation, } from '../../segmentationState';
+import { getSegmentIndexColor } from '../../config/segmentationColor';
+import { getSegmentation } from '../../getSegmentation';
 export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
-    let segmentationRepresentation, toolGroupId;
-    if (options.segmentationRepresentationUID) {
-        ({ segmentationRepresentation, toolGroupId } =
-            findSegmentationRepresentationByUID(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;
-        getColorForSegmentIndex(toolGroupId, 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');
         }
@@ -21,10 +15,9 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
             id: `segmentation_${segmentation.segmentationId}_surface_${segmentIndex}`,
             color,
             frameOfReferenceUID: 'test-frameOfReferenceUID',
-            data: {
-                points: rawSurfaceData.data.points,
-                polys: rawSurfaceData.data.polys,
-            },
+            points: rawSurfaceData.data.points,
+            polys: rawSurfaceData.data.polys,
+            segmentIndex,
         };
         const geometryId = closedSurface.id;
         geometryIds.set(segmentIndex, geometryId);
@@ -38,4 +31,3 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
         geometryIds,
     };
 }
-//# sourceMappingURL=createAndCacheSurfacesFromRaw.js.map

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

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PolySegConversionOptions } from '../../../../types';
+export type RawSurfacesData = {
+    segmentIndex: number;
+    data: Types.SurfaceData;
+}[];
+export declare function computeSurfaceData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    geometryIds: Map<number, string>;
+}>;
+declare function computeSurfaceFromLabelmapSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
+declare function computeSurfaceFromContourSegmentation(segmentationId: string, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
+export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };

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

@@ -1,8 +1,7 @@
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+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
@@ -12,13 +11,13 @@ export async function computeSurfaceData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.CONTOUR) {
+        if (representationData.Contour) {
             rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.LABELMAP) {
+        else if (representationData.Labelmap) {
             rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
                 segmentIndices,
                 ...options,
@@ -37,15 +36,14 @@ export async function computeSurfaceData(segmentationId, options = {}) {
 }
 async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    if (!segmentation?.representationData?.LABELMAP) {
+    if (!segmentation?.representationData?.Labelmap) {
         console.warn('Only support surface update from labelmaps');
         return;
     }
-    const isVolume = isVolumeSegmentation(segmentation.representationData.LABELMAP);
-    const labelmapRepresentationData = 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);
@@ -65,7 +63,7 @@ async function computeSurfaceFromLabelmapSegmentation(segmentationId, options =
 }
 async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    const contourRepresentationData = segmentation.representationData.CONTOUR;
+    const contourRepresentationData = segmentation.representationData.Contour;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map(async (index) => {
         const surface = await convertContourToSurface(contourRepresentationData, index);
@@ -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.d.ts

@@ -0,0 +1 @@
+export declare function updateSurfaceData(segmentationId: any): Promise<void>;

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

@@ -1,7 +1,9 @@
 import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, getSegmentationRepresentations, getToolGroupIdsWithSegmentation, } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+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';
@@ -13,12 +15,12 @@ export async function updateSurfaceData(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
     const indices = getUniqueSegmentIndices(segmentationId);
     if (!indices.length) {
-        const geometryIds = segmentation.representationData.SURFACE.geometryIds;
+        const geometryIds = segmentation.representationData.Surface.geometryIds;
         geometryIds.forEach((geometryId) => {
             const geometry = cache.getGeometry(geometryId);
             const surface = geometry.data;
-            surface.setPoints([]);
-            surface.setPolys([]);
+            surface.points = [];
+            surface.polys = [];
         });
         triggerSegmentationModified(segmentationId);
         return;
@@ -27,33 +29,31 @@ export async function updateSurfaceData(segmentationId) {
         const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
         const geometry = cache.getGeometry(geometryId);
         if (!geometry) {
-            const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
-            return toolGroupIds.map((toolGroupId) => {
-                const segmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-                return segmentationRepresentations.map((segmentationRepresentation) => {
-                    if (segmentationRepresentation.type !==
-                        SegmentationRepresentations.Surface) {
-                        return;
-                    }
-                    segmentation.representationData.SURFACE.geometryIds.set(segmentIndex, geometryId);
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+            return viewportIds.map((viewportId) => {
+                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,
                     });
                 });
             });
         }
         else if (indices.includes(segmentIndex)) {
             const surface = geometry.data;
-            surface.setPoints(data.points);
-            surface.setPolys(data.polys);
+            surface.points = data.points;
+            surface.polys = data.polys;
         }
         else {
             const surface = geometry.data;
-            surface.setPoints([]);
-            surface.setPolys([]);
+            surface.points = [];
+            surface.polys = [];
         }
     });
     await Promise.all(promises);
     triggerSegmentationModified(segmentationId);
 }
-//# sourceMappingURL=updateSurfaceData.js.map

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

@@ -0,0 +1,3 @@
+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,6 @@
 import { SegmentationRepresentations } from '../../../enums';
-import { validateLabelmap } from '../../../tools/displayTools/Labelmap';
-import { findSegmentationRepresentationByUID, getSegmentation, } from '../segmentationState';
+import { getSegmentation } from '../getSegmentation';
+import { validate as validateLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 const conversionPaths = new Map([
     [
         SegmentationRepresentations.Labelmap,
@@ -21,19 +21,10 @@ const conversionPaths = new Map([
         new Set([SegmentationRepresentations.Labelmap]),
     ],
 ]);
-function canComputeRequestedRepresentation(segmentationRepresentationUID) {
-    const representationInfo = findSegmentationRepresentationByUID(segmentationRepresentationUID);
-    if (!representationInfo?.segmentationRepresentation) {
-        return false;
-    }
-    const { segmentationRepresentation } = representationInfo;
-    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 = [];
@@ -65,4 +56,3 @@ async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
         false);
 }
 export { canComputeRequestedRepresentation };
-//# sourceMappingURL=canComputeRequestedRepresentation.js.map

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentations } from '../../../enums';
+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,25 @@
 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';
+import debounce from '../../../utilities/debounce';
 import { registerPolySegWorker } from './registerPolySegWorker';
 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 +45,3 @@ const _debouncedSegmentationModified = debounce((event, updateFunction) => {
     }
 }, 300);
 export { computeAndAddRepresentation };
-//# sourceMappingURL=computeAndAddRepresentation.js.map

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

@@ -0,0 +1,5 @@
+import { computeAndAddSurfaceRepresentation } from './Surface/computeAndAddSurfaceRepresentation';
+import { computeAndAddLabelmapRepresentation } from './Labelmap/computeAndAddLabelmapRepresentation';
+import { computeAndAddContourRepresentation } from './Contour/computeAndAddContourRepresentation';
+import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
+export { canComputeRequestedRepresentation, computeAndAddSurfaceRepresentation, computeAndAddLabelmapRepresentation, computeAndAddContourRepresentation, };

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.d.ts

@@ -0,0 +1 @@
+export declare function registerPolySegWorker(): void;

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

@@ -8,6 +8,7 @@ export function registerPolySegWorker() {
     const workerFn = () => {
         return new Worker(new URL('../../../workers/polySegConverters', import.meta.url), {
             name: 'polySeg',
+            type: 'module',
         });
     };
     const workerManager = getWebWorkerManager();
@@ -20,4 +21,3 @@ export function registerPolySegWorker() {
     };
     workerManager.registerWorker('polySeg', workerFn, options);
 }
-//# sourceMappingURL=registerPolySegWorker.js.map

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

@@ -0,0 +1 @@
+export declare function removeColorLUT(colorLUTIndex: number): void;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function removeColorLUT(colorLUTIndex) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.removeColorLUT(colorLUTIndex);
+}

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

@@ -0,0 +1,3 @@
+export declare function removeSegment(segmentationId: string, segmentIndex: number, options?: {
+    setNextSegmentAsActive: boolean;
+}): void;