@cornerstonejs/tools 3.0.0-beta.2 → 3.0.0-beta.3

package/dist/esm/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.js

@@ -1,88 +0,0 @@
-import { Enums, getWebWorkerManager, eventTarget, triggerEvent, } from '@cornerstonejs/core';
-import { WorkerTypes } from '../../../enums';
-import { pointToString } from '../../../utilities/pointToString';
-import { registerPolySegWorker } from '../polySeg/registerPolySegWorker';
-import { getSurfaceActorEntry } from './getSegmentationActor';
-const workerManager = getWebWorkerManager();
-const polyDataCache = new Map();
-const surfacesAABBCache = new Map();
-const triggerWorkerProgress = (eventTarget, progress) => {
-    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-        progress,
-        type: WorkerTypes.SURFACE_CLIPPING,
-    });
-};
-export async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport) {
-    registerPolySegWorker();
-    const planesInfo = viewport.getSlicesClippingPlanes?.();
-    if (!planesInfo) {
-        return;
-    }
-    const currentSliceIndex = viewport.getSliceIndex();
-    planesInfo.sort((a, b) => {
-        const diffA = Math.abs(a.sliceIndex - currentSliceIndex);
-        const diffB = Math.abs(b.sliceIndex - currentSliceIndex);
-        return diffA - diffB;
-    });
-    triggerWorkerProgress(eventTarget, 0);
-    await updateSurfacesAABBCache(surfacesInfo);
-    const surfacesAABB = new Map();
-    surfacesInfo.forEach((surface) => {
-        surfacesAABB.set(surface.id, surfacesAABBCache.get(surface.id));
-    });
-    const camera = viewport.getCamera();
-    await workerManager
-        .executeTask('polySeg', 'cutSurfacesIntoPlanes', {
-        surfacesInfo,
-        planesInfo,
-        surfacesAABB,
-    }, {
-        callbacks: [
-            ({ progress }) => {
-                triggerWorkerProgress(eventTarget, progress);
-            },
-            ({ sliceIndex, polyDataResults }) => {
-                polyDataResults.forEach((polyDataResult, segmentIndex) => {
-                    const segmentIndexNumber = Number(segmentIndex);
-                    const cacheId = generateCacheId(viewport, camera.viewPlaneNormal, sliceIndex);
-                    updatePolyDataCache(segmentIndexNumber, cacheId, polyDataResult);
-                });
-            },
-        ],
-    })
-        .catch((error) => {
-        console.error(error);
-    });
-    triggerWorkerProgress(eventTarget, 100);
-    return polyDataCache;
-}
-async function updateSurfacesAABBCache(surfacesInfo) {
-    const surfacesWithoutAABB = surfacesInfo.filter((surface) => !surfacesAABBCache.has(surface.id));
-    if (!surfacesWithoutAABB.length) {
-        return;
-    }
-    const surfacesAABB = await workerManager.executeTask('polySeg', 'getSurfacesAABBs', {
-        surfacesInfo: surfacesWithoutAABB,
-    }, {
-        callbacks: [
-            ({ progress }) => {
-                triggerWorkerProgress(eventTarget, progress);
-            },
-        ],
-    });
-    surfacesAABB.forEach((aabb, id) => {
-        surfacesAABBCache.set(id, aabb);
-    });
-}
-export function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
-    return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
-}
-export function updatePolyDataCache(segmentIndex, cacheId, polyDataResult) {
-    const { points, lines, numberOfCells } = polyDataResult;
-    let segmentCache = polyDataCache.get(segmentIndex);
-    if (!segmentCache) {
-        segmentCache = new Map();
-        polyDataCache.set(segmentIndex, segmentCache);
-    }
-    segmentCache.set(cacheId, { points, lines, numberOfCells });
-}

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

@@ -1,4 +0,0 @@
-import type { 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

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

@@ -1,8 +0,0 @@
-import type { PolySegConversionOptions } from '../../../../types';
-import type { 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

@@ -1,103 +0,0 @@
-import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
-import { clipAndCacheSurfacesForViewport } from '../../helpers/clipAndCacheSurfacesForViewport';
-import { extractContourData } from './utils/extractContourData';
-import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
-import { getSegmentation } from '../../getSegmentation';
-import { segmentationStyle } from '../../SegmentationStyle';
-import { SegmentationRepresentations } from '../../../../enums';
-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 } = options;
-    const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    segmentationStyle.setStyle({ segmentationId, type: SegmentationRepresentations.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 } = 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);
-    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 } = 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.points,
-                    polys: surface.polys,
-                    segmentIndex,
-                });
-            }
-        }
-    });
-    segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
-        surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
-    });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport);
-    const rawResults = extractContourData(polyDataCache);
-    return rawResults;
-}
-export { computeContourFromLabelmapSegmentation };

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

@@ -1,3 +0,0 @@
-import type { 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

@@ -1,71 +0,0 @@
-import PlanarFreehandContourSegmentationTool from '../../../../../tools/annotation/PlanarFreehandContourSegmentationTool';
-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

@@ -1,3 +0,0 @@
-import type { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
-import type { RawContourData } from '../contourComputationStrategies';
-export declare function extractContourData(polyDataCache: PolyDataClipCacheType): RawContourData;

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

@@ -1,16 +0,0 @@
-export function extractContourData(polyDataCache) {
-    const rawResults = new Map();
-    for (const [segmentIndex, intersectionInfo] of polyDataCache) {
-        const segmentIndexNumber = Number(segmentIndex);
-        for (const [_, result] of intersectionInfo) {
-            if (!result) {
-                continue;
-            }
-            if (!rawResults.has(segmentIndexNumber)) {
-                rawResults.set(segmentIndexNumber, []);
-            }
-            rawResults.get(segmentIndexNumber).push(result);
-        }
-    }
-    return rawResults;
-}

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-import { SegmentationRepresentations } from '../../../../enums';
-import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
-import { computeLabelmapData } from './labelmapComputationStrategies';
-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);
-    });
-}

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

@@ -1,7 +0,0 @@
-import type { 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

@@ -1,143 +0,0 @@
-import { vec3 } from 'gl-matrix';
-import { cache, utilities, getWebWorkerManager, volumeLoader, imageLoader, metaData, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
-import { getAnnotation } from '../../../annotation/annotationState';
-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.viewport;
-    const volumeId = viewport.getVolumeId();
-    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 segmentationVolume = volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
-        volumeId: segmentationVolumeId,
-    });
-    const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
-    const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
-    triggerWorkerProgress(eventTarget, 0);
-    const newScalarData = await workerManager.executeTask('polySeg', 'convertContourToVolumeLabelmap', {
-        segmentIndices,
-        dimensions,
-        scalarData: voxelManager.getCompleteScalarDataArray?.(),
-        origin,
-        direction,
-        spacing,
-        annotationUIDsInSegmentMap,
-    }, {
-        callbacks: [
-            (progress) => {
-                triggerWorkerProgress(eventTarget, progress);
-            },
-        ],
-    });
-    triggerWorkerProgress(eventTarget, 100);
-    voxelManager.setCompleteScalarDataArray(newScalarData);
-    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 segImages = await imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
-    const segmentationImageIds = segImages.map((it) => it.imageId);
-    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.voxelManager.getScalarData(),
-            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, 100);
-    const segImageIds = [];
-    newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
-        const segmentationInfo = segmentationsInfo.get(referencedImageId);
-        const { imageId: segImageId } = segmentationInfo;
-        const segImage = cache.getImage(segImageId);
-        segImage.voxelManager.getScalarData().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

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

@@ -1,49 +0,0 @@
-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.points;
-        const polys = geometryData.polys;
-        segmentsInfo.set(segmentIndex, {
-            points,
-            polys,
-        });
-    });
-    const { dimensions, direction, origin, spacing, voxelManager } = segmentationVolume;
-    triggerWorkerProgress(eventTarget, 0);
-    const newScalarData = await workerManager.executeTask('polySeg', 'convertSurfacesToVolumeLabelmap', {
-        segmentsInfo,
-        dimensions,
-        spacing,
-        direction,
-        origin,
-    }, {
-        callbacks: [
-            (progress) => {
-                triggerWorkerProgress(eventTarget, progress);
-            },
-        ],
-    });
-    triggerWorkerProgress(eventTarget, 100);
-    voxelManager.setCompleteScalarDataArray(newScalarData);
-    segmentationVolume.modified();
-    return {
-        volumeId: segmentationVolume.volumeId,
-    };
-}
-export async function convertSurfaceToStackLabelmap() {
-}

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

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