@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -0,0 +1,7 @@
+import { internalConvertStackToVolumeLabelmap } from '../SegmentationStateManager';
+import { triggerSegmentationModified } from '../triggerSegmentationEvents';
+export async function convertStackToVolumeLabelmap(args) {
+    const result = internalConvertStackToVolumeLabelmap(args);
+    triggerSegmentationModified(args.segmentationId);
+    return result;
+}

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.d.ts

@@ -0,0 +1,8 @@
+import { type Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../../enums';
+export declare function getSegmentationActor(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): Types.VolumeActor | Types.ImageActor | undefined;
+export declare function getLabelmapActorUID(segmentationId: string): string;
+export declare function getSurfaceActorUID(segmentationId: string): string;

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

@@ -0,0 +1,27 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../../enums';
+export function getSegmentationActor(viewportId, specifier) {
+    if (specifier.type === SegmentationRepresentations.Contour) {
+        throw new Error('Contours do not have actors');
+    }
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    const { renderingEngine, viewport } = enabledElement;
+    if (!renderingEngine || !viewport) {
+        return;
+    }
+    const actors = viewport.getActors();
+    const actorUID = specifier.type === SegmentationRepresentations.Labelmap
+        ? getLabelmapActorUID(specifier.segmentationId)
+        : getSurfaceActorUID(specifier.segmentationId);
+    const actor = actors.find((actor) => actor.uid === actorUID);
+    if (!actor) {
+        return;
+    }
+    return actor.actor;
+}
+export function getLabelmapActorUID(segmentationId) {
+    return `${segmentationId}-${SegmentationRepresentations.Labelmap}`;
+}
+export function getSurfaceActorUID(segmentationId) {
+    return `${segmentationId}-${SegmentationRepresentations.Surface}`;
+}

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

@@ -1,2 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-export { validateSegmentationInput };
+import { getSegmentationActor } from './getSegmentationActor';
+export { validateSegmentationInput, getSegmentationActor };

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

@@ -1,3 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-export { validateSegmentationInput };
-//# sourceMappingURL=index.js.map
+import { getSegmentationActor } from './getSegmentationActor';
+export { validateSegmentationInput, getSegmentationActor };

package/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.d.ts

@@ -0,0 +1,5 @@
+import type { SegmentationRepresentations } from '../../../enums';
+export declare function internalGetHiddenSegmentIndices(viewportId: any, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): Set<unknown>;

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

@@ -0,0 +1,14 @@
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
+export function internalGetHiddenSegmentIndices(viewportId, specifier) {
+    const representation = getSegmentationRepresentation(viewportId, specifier);
+    if (!representation) {
+        return new Set();
+    }
+    const segmentsHidden = Object.entries(representation.segments).reduce((acc, [segmentIndex, segment]) => {
+        if (!segment.visible) {
+            acc.add(Number(segmentIndex));
+        }
+        return acc;
+    }, new Set());
+    return segmentsHidden;
+}

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
 declare function normalizeSegmentationInput(segmentationInput: SegmentationPublicInput): Segmentation;
 export default normalizeSegmentationInput;

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

@@ -1,19 +1,35 @@
+import { SegmentationRepresentations } from '../../../enums';
 function normalizeSegmentationInput(segmentationInput) {
-    const { segmentationId, representation } = segmentationInput;
+    const { segmentationId, representation, config } = segmentationInput;
+    const { type, data: inputData } = representation;
+    const data = inputData ? { ...inputData } : {};
+    if (!data) {
+        throw new Error('Segmentation representation data may not be undefined');
+    }
+    if (type === SegmentationRepresentations.Contour) {
+        const contourData = data;
+        contourData.geometryIds = contourData.geometryIds ?? [];
+        contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
+    }
+    const normalizedSegments = {};
+    Object.entries(config.segments).forEach(([segmentIndex, segment]) => {
+        normalizedSegments[segmentIndex] = {
+            segmentIndex: Number(segmentIndex),
+            label: segment.label ?? `Segment ${segmentIndex}`,
+            locked: segment.locked ?? false,
+            cachedStats: segment.cachedStats ?? {},
+            active: segment.active ?? false,
+        };
+    });
     return {
         segmentationId,
-        cachedStats: {},
-        segmentLabels: {},
-        label: null,
-        segmentsLocked: new Set(),
-        type: representation.type,
-        activeSegmentIndex: 1,
+        label: config.label ?? null,
+        segments: normalizedSegments,
         representationData: {
-            [representation.type]: {
-                ...representation.data,
+            [type]: {
+                ...data,
             },
         },
     };
 }
 export default normalizeSegmentationInput;
-//# sourceMappingURL=normalizeSegmentationInput.js.map

package/dist/esm/stateManagement/segmentation/helpers/updateStackSegmentationState.d.ts

@@ -0,0 +1,8 @@
+export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
+    segmentationId: string;
+    viewportId: string;
+    imageIds: string[];
+    options?: {
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;

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

@@ -0,0 +1,31 @@
+import { cache, eventTarget } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../getSegmentation';
+import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
+import { addSegmentationRepresentations } from '../addSegmentationRepresentationsToViewport';
+export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (options?.removeOriginal) {
+        const data = segmentation.representationData
+            .Labelmap;
+        if (cache.getVolume(data.volumeId)) {
+            cache.removeVolumeLoadObject(data.volumeId);
+        }
+        segmentation.representationData.Labelmap = {
+            imageIds,
+        };
+    }
+    else {
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            imageIds,
+        };
+    }
+    await addSegmentationRepresentations(viewportId, [
+        {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        },
+    ]);
+    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
+}

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
 declare function validateSegmentationInput(segmentationInputArray: SegmentationPublicInput[]): void;
 export default validateSegmentationInput;

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

@@ -1,21 +1,20 @@
 import * as Enums from '../../../enums';
-import validateLabelmap from '../../../tools/displayTools/Labelmap/validateRepresentationData';
+import { validatePublic as validatePublicLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 function validateSegmentationInput(segmentationInputArray) {
-    if (!segmentationInputArray || !segmentationInputArray.length) {
-        throw new Error('The segmentationInputArray is undefined or empty array');
+    if (!segmentationInputArray || segmentationInputArray.length === 0) {
+        throw new Error('The segmentationInputArray is undefined or an empty array');
     }
     segmentationInputArray.forEach((segmentationInput) => {
         if (segmentationInput.segmentationId === undefined) {
-            throw new Error('The segmentationInput.segmentationId is undefined, please provide a valid segmentationId');
+            throw new Error('Undefined segmentationInput.segmentationId. Please provide a valid segmentationId');
         }
         if (segmentationInput.representation === undefined) {
-            throw new Error('The segmentationInput.representation is undefined, please provide a valid representation');
+            throw new Error('Undefined segmentationInput.representation. Please provide a valid representation');
         }
         if (segmentationInput.representation.type ===
             Enums.SegmentationRepresentations.Labelmap) {
-            validateLabelmap(segmentationInput);
+            validatePublicLabelmap(segmentationInput);
         }
     });
 }
 export default validateSegmentationInput;
-//# sourceMappingURL=validateSegmentationInput.js.map

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

@@ -1,10 +1,23 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
-import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
 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 { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
+import * as polySegManager from './polySeg';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+declare const helpers: {
+    clearSegmentValue: typeof clearSegmentValue;
+    convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
+    computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
+    convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, };

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

@@ -1,11 +1,23 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
-import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
 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 { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
+import * as polySegManager from './polySeg';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+const helpers = {
+    clearSegmentValue,
+    convertStackToVolumeLabelmap,
+    computeVolumeLabelmapFromStack,
+    convertVolumeToStackLabelmap,
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, };

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

@@ -0,0 +1,12 @@
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import type { ContourSegmentationData } from '../../types/ContourTypes';
+import type { SurfaceSegmentationData } from '../../types/SurfaceTypes';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+type SegmentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
+type AddRepresentationData = {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+    data: SegmentationData;
+};
+declare function internalAddRepresentationData({ segmentationId, type, data, }: AddRepresentationData): void;
+export default internalAddRepresentationData;

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

@@ -0,0 +1,32 @@
+import { getSegmentation } from './getSegmentation';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+function internalAddRepresentationData({ segmentationId, type, data, }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        throw new Error(`Segmentation ${segmentationId} not found`);
+    }
+    if (segmentation.representationData[type]) {
+        console.warn(`Representation data of type ${type} already exists for segmentation ${segmentationId}, overwriting it.`);
+    }
+    switch (type) {
+        case SegmentationRepresentations.Labelmap:
+            if (data) {
+                segmentation.representationData[type] =
+                    data;
+            }
+            break;
+        case SegmentationRepresentations.Contour:
+            if (data) {
+                segmentation.representationData[type] = data;
+            }
+            break;
+        case SegmentationRepresentations.Surface:
+            if (data) {
+                segmentation.representationData[type] = data;
+            }
+            break;
+        default:
+            throw new Error(`Invalid representation type ${type}`);
+    }
+}
+export default internalAddRepresentationData;

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

@@ -0,0 +1,3 @@
+import type { RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function internalAddSegmentationRepresentation(viewportId: string, representationInput: RepresentationPublicInput): void;
+export { internalAddSegmentationRepresentation };

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

@@ -0,0 +1,34 @@
+import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
+import { SegmentationRepresentations } from '../../enums';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import { addColorLUT } from './addColorLUT';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getColorLUT } from './getColorLUT';
+function internalAddSegmentationRepresentation(viewportId, representationInput) {
+    const { segmentationId, config } = representationInput;
+    const renderingConfig = {
+        colorLUTIndex: getColorLUTIndex(config),
+    };
+    defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    if (representationInput.type === SegmentationRepresentations.Contour) {
+        triggerAnnotationRenderForViewportIds([viewportId]);
+    }
+    triggerSegmentationModified(segmentationId);
+}
+function getColorLUTIndex(config) {
+    const { colorLUTOrIndex } = config || {};
+    const isIndexProvided = typeof colorLUTOrIndex === 'number';
+    const selectedColorLUT = isIndexProvided
+        ? getColorLUT(colorLUTOrIndex)
+        : CORNERSTONE_COLOR_LUT;
+    const colorLUTIndex = isIndexProvided
+        ? colorLUTOrIndex
+        : getNextColorLUTIndex();
+    if (!isIndexProvided) {
+        addColorLUT(selectedColorLUT, colorLUTIndex);
+    }
+    return colorLUTIndex;
+}
+export { internalAddSegmentationRepresentation };

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

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

@@ -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 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

@@ -0,0 +1,102 @@
+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, segmentationId);
+    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.getPoints(),
+                    polys: surface.getPolys(),
+                });
+            }
+        }
+    });
+    segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
+        surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
+    });
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationId);
+    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 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

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

@@ -0,0 +1,3 @@
+import type { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import type { 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,23 @@
+export function extractContourData(polyDataCache, segmentIndexMap) {
+    const rawResults = new Map();
+    for (const [cacheId, intersectionInfo] of polyDataCache) {
+        let segmentIndex;
+        const surfaceId = cacheId.split('-')[1];
+        if (!segmentIndexMap) {
+            segmentIndex = Number(surfaceId.split('_')[1]);
+        }
+        else {
+            segmentIndex = segmentIndexMap.get(surfaceId.split('_')[1]);
+        }
+        for (const [_, result] of intersectionInfo) {
+            if (!result) {
+                continue;
+            }
+            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 type { PolySegConversionOptions } from '../../../../types';
+export declare function computeAndAddLabelmapRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<import("./labelmapComputationStrategies").RawLabelmapData>;