@cornerstonejs/tools 2.0.0-beta.2 → 2.0.0-beta.20

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

@@ -1,10 +1,14 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
+import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
 import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
+import addRepresentationData from './addRepresentationData';
+import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
+import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
 import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
-export { state, addSegmentations, activeSegmentation, addSegmentationRepresentations, removeSegmentationsFromToolGroup, segmentLocking, config, segmentIndex, triggerSegmentationEvents, };
+import * as polySegManager from './polySeg';
+export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

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

@@ -1,11 +1,14 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
+import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
 import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
+import addRepresentationData from './addRepresentationData';
+import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
+import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
 import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
-export { state, addSegmentations, activeSegmentation, addSegmentationRepresentations, removeSegmentationsFromToolGroup, segmentLocking, config, segmentIndex, triggerSegmentationEvents, };
-//# sourceMappingURL=index.js.map
+import * as polySegManager from './polySeg';
+export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.d.ts

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

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

@@ -0,0 +1,6 @@
+import { SegmentationRepresentations } from '../../../../enums';
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeContourData } from './contourComputationStrategies';
+export function computeAndAddContourRepresentation(segmentationId, options = {}) {
+    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Contour, () => computeContourData(segmentationId, options), () => undefined);
+}

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.d.ts

@@ -0,0 +1,8 @@
+import { PolySegConversionOptions } from '../../../../types';
+import { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
+export type RawContourData = Map<number, SurfaceClipResult[]>;
+export declare function computeContourData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    annotationUIDsMap: Map<number, Set<string>>;
+}>;
+declare function computeContourFromLabelmapSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<RawContourData>;
+export { computeContourFromLabelmapSegmentation };

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

@@ -0,0 +1,102 @@
+import { cache } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import { getSegmentation, setAllSegmentsConfig } from '../../segmentationState';
+import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
+import { clipAndCacheSurfacesForViewport, } from '../../helpers/clipAndCacheSurfacesForViewport';
+import { extractContourData } from './utils/extractContourData';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
+export async function computeContourData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    let rawContourData;
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.SURFACE) {
+            rawContourData = await computeContourFromSurfaceSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.LABELMAP) {
+            rawContourData = await computeContourFromLabelmapSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    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 annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
+    setAllSegmentsConfig(segmentationRepresentationUID, {
+        CONTOUR: {
+            fillAlpha: 0,
+        },
+    });
+    return {
+        annotationUIDsMap,
+    };
+}
+async function computeContourFromLabelmapSegmentation(segmentationId, options = {}) {
+    if (!options.viewport) {
+        throw new Error('Viewport is required to compute contour from labelmap');
+    }
+    const results = await computeSurfaceFromLabelmapSegmentation(segmentationId, options);
+    if (!results?.length) {
+        console.error('Failed to convert labelmap to surface or labelmap is empty');
+        return;
+    }
+    const { viewport, segmentationRepresentationUID } = options;
+    const pointsAndPolys = results.map((surface) => {
+        return {
+            id: surface.segmentIndex.toString(),
+            points: surface.data.points,
+            polys: surface.data.polys,
+            segmentIndex: surface.segmentIndex,
+        };
+    });
+    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationRepresentationUID);
+    const rawResults = extractContourData(polyDataCache);
+    return rawResults;
+}
+async function computeContourFromSurfaceSegmentation(segmentationId, options = {}) {
+    if (!options.viewport) {
+        throw new Error('Viewport is required to compute contour from surface');
+    }
+    const { viewport, segmentationRepresentationUID } = options;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    const segmentIndexToSurfaceId = new Map();
+    const surfaceIdToSegmentIndex = new Map();
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData.SURFACE;
+    const surfacesInfo = [];
+    representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+        if (segmentIndices.includes(segmentIndex)) {
+            segmentIndexToSurfaceId.set(segmentIndex, geometryId);
+            const surface = cache.getGeometry(geometryId)?.data;
+            if (surface) {
+                surfacesInfo.push({
+                    id: geometryId,
+                    points: surface.getPoints(),
+                    polys: surface.getPolys(),
+                });
+            }
+        }
+    });
+    segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
+        surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
+    });
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
+    const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
+    return rawResults;
+}
+export { computeContourFromLabelmapSegmentation };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.d.ts

@@ -0,0 +1,3 @@
+import { RawContourData } from '../contourComputationStrategies';
+import { type Types } from '@cornerstonejs/core';
+export declare function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData: RawContourData, viewport: Types.IViewport, segmentationId: string): Map<number, Set<string>>;

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

@@ -0,0 +1,71 @@
+import { PlanarFreehandContourSegmentationTool } from '../../../../../tools';
+import { addAnnotation } from '../../../../annotation/annotationState';
+import { utilities } from '@cornerstonejs/core';
+export function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId) {
+    const annotationUIDsMap = new Map();
+    for (const [segmentIndex, contoursData] of rawContourData) {
+        for (const contourData of contoursData) {
+            const { points } = contourData;
+            const { lineSegments, linesNumberOfPoints } = _extractLineSegments(contourData);
+            for (let i = 0; i < lineSegments.length; i++) {
+                const line = lineSegments[i];
+                const polyline = [];
+                for (let j = 0; j < linesNumberOfPoints[i]; j++) {
+                    const pointIndex = line[j];
+                    polyline.push([
+                        points[3 * pointIndex],
+                        points[3 * pointIndex + 1],
+                        points[3 * pointIndex + 2],
+                    ]);
+                }
+                if (polyline.length < 3) {
+                    continue;
+                }
+                const contourSegmentationAnnotation = {
+                    annotationUID: utilities.uuidv4(),
+                    data: {
+                        contour: {
+                            closed: true,
+                            polyline,
+                        },
+                        segmentation: {
+                            segmentationId,
+                            segmentIndex,
+                        },
+                        handles: {},
+                    },
+                    handles: {},
+                    highlighted: false,
+                    autoGenerated: false,
+                    invalidated: false,
+                    isLocked: false,
+                    isVisible: true,
+                    metadata: {
+                        toolName: PlanarFreehandContourSegmentationTool.toolName,
+                        ...viewport.getViewReference(),
+                    },
+                };
+                addAnnotation(contourSegmentationAnnotation, viewport.element);
+                const currentSet = annotationUIDsMap.get(segmentIndex) || new Set();
+                currentSet.add(contourSegmentationAnnotation.annotationUID);
+                annotationUIDsMap.set(segmentIndex, currentSet);
+            }
+        }
+    }
+    return annotationUIDsMap;
+}
+const _extractLineSegments = (contourData) => {
+    const { numberOfCells, lines } = contourData;
+    const lineSegments = [];
+    const linesNumberOfPoints = [];
+    for (let i = 0; i < lines.length;) {
+        const pointsInLine = lines[i];
+        linesNumberOfPoints.push(pointsInLine);
+        lineSegments.push(lines.slice(i + 1, i + pointsInLine + 1));
+        i += pointsInLine + 1;
+        if (lineSegments.length === numberOfCells) {
+            break;
+        }
+    }
+    return { lineSegments, linesNumberOfPoints };
+};

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.d.ts

@@ -0,0 +1,3 @@
+import { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { RawContourData } from '../contourComputationStrategies';
+export declare function extractContourData(polyDataCache: PolyDataClipCacheType, segmentIndexMap?: Map<string, number>): RawContourData;

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

@@ -0,0 +1,20 @@
+export function extractContourData(polyDataCache, segmentIndexMap) {
+    const rawResults = new Map();
+    for (const [cacheId, intersectionInfo] of polyDataCache) {
+        const surfaceId = cacheId.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, []);
+            }
+            rawResults.get(segmentIndex).push(result);
+        }
+    }
+    return rawResults;
+}

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.d.ts

@@ -0,0 +1 @@
+export declare function updateContoursOnCameraModified(surfacesInfo: any, viewport: any, segmentationRepresentationUID: any): void;

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

@@ -0,0 +1,25 @@
+import { utilities, Enums } from '@cornerstonejs/core';
+import { extractContourData } from './extractContourData';
+import { clipAndCacheSurfacesForViewport } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './createAndAddContourSegmentationsFromClippedSurfaces';
+const currentViewportNormal = new Map();
+export function updateContoursOnCameraModified(surfacesInfo, viewport, segmentationRepresentationUID) {
+    async function cameraModifiedCallback(evt) {
+        const { camera } = evt.detail;
+        const { viewPlaneNormal } = camera;
+        const surface1 = surfacesInfo[0];
+        const currentNormal = currentViewportNormal.get(surface1.id);
+        if (utilities.isEqual(viewPlaneNormal, currentNormal)) {
+            return;
+        }
+        currentViewportNormal.set(surface1.id, viewPlaneNormal);
+        const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
+        const results = extractContourData(polyDataCache);
+        createAndAddContourSegmentationsFromClippedSurfaces(results, viewport, segmentationRepresentationUID);
+        viewport.render();
+    }
+    const camera = viewport.getCamera();
+    currentViewportNormal.set(surfacesInfo[0].id, camera.viewPlaneNormal);
+    viewport.element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraModifiedCallback);
+    viewport.element.addEventListener(Enums.Events.CAMERA_MODIFIED);
+}

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

@@ -0,0 +1,2 @@
+import { PolySegConversionOptions } from '../../../../types';
+export declare function computeAndAddLabelmapRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<import("./labelmapComputationStrategies").RawLabelmapData>;

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

@@ -0,0 +1,6 @@
+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);
+}

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

@@ -0,0 +1,7 @@
+import { ContourSegmentationData, PolySegConversionOptions } from '../../../../types';
+export declare function convertContourToVolumeLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
+    volumeId: string;
+}>;
+export declare function convertContourToStackLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
+    imageIds: any[];
+}>;

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

@@ -0,0 +1,152 @@
+import { vec3 } from 'gl-matrix';
+import { cache, utilities, getWebWorkerManager, volumeLoader, imageLoader, metaData, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
+import { getAnnotation } from '../../..';
+import { WorkerTypes } from '../../../../enums';
+const workerManager = getWebWorkerManager();
+const triggerWorkerProgress = (eventTarget, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.POLYSEG_CONTOUR_TO_LABELMAP,
+    });
+};
+export async function convertContourToVolumeLabelmap(contourRepresentationData, options = {}) {
+    const { viewport } = options;
+    const imageIds = utilities.getViewportImageIds(viewport);
+    if (!imageIds) {
+        throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
+    }
+    const segmentationVolumeId = utilities.uuidv4();
+    const volumeProps = utilities.generateVolumePropsFromImageIds(imageIds, segmentationVolumeId);
+    const { metadata, dimensions, origin, direction, spacing, scalarData } = volumeProps;
+    const segmentationVolume = await volumeLoader.createLocalSegmentationVolume({
+        dimensions,
+        origin,
+        direction,
+        spacing,
+        metadata,
+        imageIds: imageIds.map((imageId) => `generated://${imageId}`),
+        referencedImageIds: imageIds,
+    }, segmentationVolumeId);
+    const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+    triggerWorkerProgress(eventTarget, 0);
+    const newScalarData = await workerManager.executeTask('polySeg', 'convertContourToVolumeLabelmap', {
+        segmentIndices,
+        dimensions,
+        scalarData,
+        origin,
+        direction,
+        spacing,
+        annotationUIDsInSegmentMap,
+    }, {
+        callbacks: [
+            (progress) => {
+                triggerWorkerProgress(eventTarget, progress);
+            },
+        ],
+    });
+    triggerWorkerProgress(eventTarget, 1);
+    segmentationVolume.imageData
+        .getPointData()
+        .getScalars()
+        .setData(newScalarData);
+    segmentationVolume.imageData.modified();
+    segmentationVolume.modified();
+    return {
+        volumeId: segmentationVolume.volumeId,
+    };
+}
+export async function convertContourToStackLabelmap(contourRepresentationData, options = {}) {
+    if (!options.viewport) {
+        throw new Error('No viewport provided, labelmap computation from contour requires viewports');
+    }
+    const viewport = options.viewport;
+    const imageIds = viewport.getImageIds();
+    if (!imageIds) {
+        throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
+    }
+    imageIds.forEach((imageId) => {
+        if (!cache.getImageLoadObject(imageId)) {
+            throw new Error('ImageIds must be cached before converting contour to labelmap');
+        }
+    });
+    const { imageIds: segmentationImageIds } = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+    const segmentationsInfo = new Map();
+    segmentationImageIds.forEach((segImageId, index) => {
+        const segImage = cache.getImage(segImageId);
+        const imagePlaneModule = metaData.get(Enums.MetadataModules.IMAGE_PLANE, segImageId);
+        let { columnCosines, rowCosines, rowPixelSpacing, columnPixelSpacing, imagePositionPatient, } = imagePlaneModule;
+        columnCosines = columnCosines ?? [0, 1, 0];
+        rowCosines = rowCosines ?? [1, 0, 0];
+        rowPixelSpacing = rowPixelSpacing ?? 1;
+        columnPixelSpacing = columnPixelSpacing ?? 1;
+        imagePositionPatient = imagePositionPatient ?? [0, 0, 0];
+        const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+        const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        const scanAxisNormal = vec3.create();
+        vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+        const direction = [...rowCosineVec, ...colCosineVec, ...scanAxisNormal];
+        const spacing = [rowPixelSpacing, columnPixelSpacing, 1];
+        const origin = imagePositionPatient;
+        segmentationsInfo.set(imageIds[index], {
+            direction,
+            spacing,
+            origin,
+            scalarData: segImage.getPixelData(),
+            imageId: segImageId,
+            dimensions: [segImage.width, segImage.height, 1],
+        });
+    });
+    triggerWorkerProgress(eventTarget, 0);
+    const newSegmentationsScalarData = await workerManager.executeTask('polySeg', 'convertContourToStackLabelmap', {
+        segmentationsInfo,
+        annotationUIDsInSegmentMap,
+        segmentIndices,
+    }, {
+        callbacks: [
+            (progress) => {
+                triggerWorkerProgress(eventTarget, progress);
+            },
+        ],
+    });
+    triggerWorkerProgress(eventTarget, 1);
+    const segImageIds = [];
+    newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
+        const segmentationInfo = segmentationsInfo.get(referencedImageId);
+        const { imageId: segImageId } = segmentationInfo;
+        const segImage = cache.getImage(segImageId);
+        segImage.getPixelData().set(scalarData);
+        segImage.imageFrame?.pixelData?.set(scalarData);
+        segImageIds.push(segImageId);
+    });
+    return {
+        imageIds: segImageIds,
+    };
+}
+function _getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {
+    const annotationMap = contourRepresentationData.annotationUIDsMap;
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : Array.from(annotationMap.keys());
+    const annotationUIDsInSegmentMap = new Map();
+    segmentIndices.forEach((index) => {
+        const annotationUIDsInSegment = annotationMap.get(index);
+        let uids = Array.from(annotationUIDsInSegment);
+        uids = uids.filter((uid) => !getAnnotation(uid).parentAnnotationUID);
+        const annotations = uids.map((uid) => {
+            const annotation = getAnnotation(uid);
+            const hasChildAnnotations = annotation.childAnnotationUIDs?.length;
+            return {
+                polyline: annotation.data.contour.polyline,
+                referencedImageId: annotation.metadata.referencedImageId,
+                holesPolyline: hasChildAnnotations &&
+                    annotation.childAnnotationUIDs.map((childUID) => {
+                        const childAnnotation = getAnnotation(childUID);
+                        return childAnnotation.data.contour.polyline;
+                    }),
+            };
+        });
+        annotationUIDsInSegmentMap.set(index, annotations);
+    });
+    return { segmentIndices, annotationUIDsInSegmentMap };
+}

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

@@ -0,0 +1,6 @@
+import { Types } from '@cornerstonejs/core';
+import { 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

@@ -0,0 +1,53 @@
+import { Enums, cache, eventTarget, getWebWorkerManager, triggerEvent, } from '@cornerstonejs/core';
+import { WorkerTypes } from '../../../../enums';
+const workerManager = getWebWorkerManager();
+const triggerWorkerProgress = (eventTarget, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.POLYSEG_SURFACE_TO_LABELMAP,
+    });
+};
+export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData, segmentationVolume) {
+    const { geometryIds } = surfaceRepresentationData;
+    if (!geometryIds?.size) {
+        throw new Error('No geometry IDs found for surface representation');
+    }
+    const segmentsInfo = new Map();
+    geometryIds.forEach((geometryId, segmentIndex) => {
+        const geometry = cache.getGeometry(geometryId);
+        const geometryData = geometry.data;
+        const points = geometryData.getPoints();
+        const polys = geometryData.getPolys();
+        segmentsInfo.set(segmentIndex, {
+            points,
+            polys,
+        });
+    });
+    const { dimensions, direction, origin, spacing } = segmentationVolume;
+    triggerWorkerProgress(eventTarget, 0);
+    const newScalarData = await workerManager.executeTask('polySeg', 'convertSurfacesToVolumeLabelmap', {
+        segmentsInfo,
+        dimensions,
+        spacing,
+        direction,
+        origin,
+    }, {
+        callbacks: [
+            (progress) => {
+                triggerWorkerProgress(eventTarget, progress);
+            },
+        ],
+    });
+    triggerWorkerProgress(eventTarget, 1);
+    segmentationVolume.imageData
+        .getPointData()
+        .getScalars()
+        .setData(newScalarData);
+    segmentationVolume.imageData.modified();
+    segmentationVolume.modified();
+    return {
+        volumeId: segmentationVolume.volumeId,
+    };
+}
+export async function convertSurfaceToStackLabelmap() {
+}

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

@@ -0,0 +1,6 @@
+import { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
+import { 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

@@ -0,0 +1,100 @@
+import { VolumeViewport, volumeLoader, utilities } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import { getSegmentation } from '../../segmentationState';
+import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
+import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
+import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
+export async function computeLabelmapData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    let rawLabelmapData;
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.CONTOUR) {
+            rawLabelmapData = await computeLabelmapFromContourSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.SURFACE) {
+            rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(segmentation.segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    if (!rawLabelmapData) {
+        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
+    }
+    return rawLabelmapData;
+}
+async function computeLabelmapFromContourSegmentation(segmentationId, options = {}) {
+    const isVolume = options.viewport instanceof VolumeViewport ?? true;
+    if (isVolume && !options.viewport) {
+        throw new Error('Cannot compute labelmap from contour segmentation without providing the viewport');
+    }
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
+    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 segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
+    const segmentsGeometryIds = new Map();
+    const representationData = segmentation.representationData.SURFACE;
+    representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+        if (segmentIndices.includes(segmentIndex)) {
+            segmentsGeometryIds.set(segmentIndex, geometryId);
+        }
+    });
+    if (isVolume && !options.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);
+    }
+    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 result = await convertSurfaceToVolumeLabelmap({ geometryIds: segmentsGeometryIds }, segmentationVolume);
+    if (isVolume) {
+        return result;
+    }
+    const stackData = (await computeStackSegmentationFromVolume({
+        volumeId: segmentationVolume.volumeId,
+    }));
+    return stackData;
+}
+export { computeLabelmapFromContourSegmentation };

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

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