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

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.js

@@ -16,4 +16,3 @@ export function triggerSegmentationModified(segmentationId) {
         triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
     });
 }
-//# sourceMappingURL=triggerSegmentationModified.js.map

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.js

@@ -6,4 +6,3 @@ export function triggerSegmentationRemoved(segmentationId) {
     };
     triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
 }
-//# sourceMappingURL=triggerSegmentationRemoved.js.map

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

@@ -5,4 +5,3 @@ export function getActiveSegmentIndex(segmentationId) {
         return segmentation.activeSegmentIndex;
     }
 }
-//# sourceMappingURL=getActiveSegmentIndex.js.map

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

@@ -0,0 +1,2 @@
+import type { Segmentation } from '../../types';
+export declare function getActiveSegmentation(viewportId: string): Segmentation | undefined;

package/dist/esm/stateManagement/segmentation/{getGlobalConfig.js → getActiveSegmentation.js}

@@ -1,6 +1,5 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-export function getGlobalConfig() {
+export function getActiveSegmentation(viewportId) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    return segmentationStateManager.getGlobalConfig();
+    return segmentationStateManager.getActiveSegmentation(viewportId);
 }
-//# sourceMappingURL=getGlobalConfig.js.map

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

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

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

@@ -1 +1 @@
-export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId?: string): string;
+export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string;

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

@@ -3,4 +3,3 @@ export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId)
     const segmentationStateManager = defaultSegmentationStateManager;
     return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
 }
-//# sourceMappingURL=getCurrentLabelmapImageIdForViewport.js.map

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentations } from '../../enums';
+import type { RepresentationStyle } from './SegmentationStyle';
+export declare function getGlobalStyle(type: SegmentationRepresentations): RepresentationStyle;

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

@@ -0,0 +1,4 @@
+import { segmentationStyle } from './SegmentationStyle';
+export function getGlobalStyle(type) {
+    return segmentationStyle.getGlobalStyle(type);
+}

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

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

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

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

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

@@ -1,2 +1,10 @@
+import type { SegmentationRepresentations } from '../../enums';
 import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
-export declare function getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+export declare function getSegmentationRepresentations(viewportId: string, specifier?: {
+    segmentationId?: string;
+    type?: SegmentationRepresentations;
+}): SegmentationRepresentation[] | [];
+export declare function getSegmentationRepresentation(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): SegmentationRepresentation | undefined;

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

@@ -1,6 +1,13 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-export function getSegmentationRepresentation(segmentationRepresentationUID) {
+export function getSegmentationRepresentations(viewportId, specifier = {}) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    return segmentationStateManager.getSegmentationRepresentation(segmentationRepresentationUID);
+    return segmentationStateManager.getSegmentationRepresentations(viewportId, specifier);
+}
+export function getSegmentationRepresentation(viewportId, specifier) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    if (!specifier.segmentationId || !specifier.type) {
+        throw new Error('getSegmentationRepresentation: No segmentationId or type provided, you need to provide at least one of them');
+    }
+    const representations = segmentationStateManager.getSegmentationRepresentations(viewportId, specifier);
+    return representations?.[0];
 }
-//# sourceMappingURL=getSegmentationRepresentation.js.map

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

@@ -1 +1,5 @@
-export declare function getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+import type { SegmentationRepresentations } from '../../enums';
+export declare function getSegmentationRepresentationVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): boolean;

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

@@ -1,6 +1,5 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-export function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+export function getSegmentationRepresentationVisibility(viewportId, specifier) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
+    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, specifier);
 }
-//# sourceMappingURL=getSegmentationRepresentationVisibility.js.map

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

@@ -4,4 +4,3 @@ export function getSegmentations() {
     const state = segmentationStateManager.getState();
     return state.segmentations;
 }
-//# sourceMappingURL=getSegmentations.js.map

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

@@ -3,4 +3,3 @@ export function getStackSegmentationImageIdsForViewport(viewportId, segmentation
     const segmentationStateManager = defaultSegmentationStateManager;
     return segmentationStateManager.getStackSegmentationImageIdsForViewport(viewportId, segmentationId);
 }
-//# sourceMappingURL=getStackSegmentationImageIdsForViewport.js.map

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

@@ -2,10 +2,9 @@ import { defaultSegmentationStateManager } from './SegmentationStateManager';
 export function getViewportIdsWithSegmentation(segmentationId) {
     const segmentationStateManager = defaultSegmentationStateManager;
     const state = segmentationStateManager.getState();
-    const viewports = state.viewports;
-    return Object.keys(viewports).filter((viewportId) => {
-        const viewport = viewports[viewportId];
-        return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
-    });
+    const viewportSegRepresentations = state.viewportSegRepresentations;
+    const viewportIdsWithSegmentation = Object.entries(viewportSegRepresentations)
+        .filter(([, viewportSegmentations]) => viewportSegmentations.some((segRep) => segRep.segmentationId === segmentationId))
+        .map(([viewportId]) => viewportId);
+    return viewportIdsWithSegmentation;
 }
-//# sourceMappingURL=getViewportIdsWithSegmentation.js.map

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentations } from '../../enums';
+import type { Segmentation } from '../../types';
+export declare function getViewportSegmentations(viewportId: string, type?: SegmentationRepresentations): Segmentation[];

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

@@ -0,0 +1,15 @@
+import { getSegmentation } from './getSegmentation';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getViewportSegmentations(viewportId, type) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    const viewportRepresentations = state.viewportSegRepresentations[viewportId];
+    const segmentations = viewportRepresentations.map((representation) => {
+        if (type && representation.type === type) {
+            return getSegmentation(representation.segmentationId);
+        }
+        return getSegmentation(representation.segmentationId);
+    });
+    const filteredSegmentations = segmentations.filter((segmentation) => segmentation !== undefined);
+    return filteredSegmentations;
+}

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

@@ -0,0 +1 @@
+export declare function clearSegmentValue(segmentationId: string, segmentIndex: number): void;

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

@@ -0,0 +1,31 @@
+import { cache } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../getSegmentation';
+import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
+export function clearSegmentValue(segmentationId, segmentIndex) {
+    const segmentation = getSegmentation(segmentationId);
+    if (segmentation.representationData.Labelmap) {
+        const { representationData } = segmentation;
+        const labelmapData = representationData.Labelmap;
+        if ('imageIds' in labelmapData || 'volumeId' in labelmapData) {
+            const items = 'imageIds' in labelmapData
+                ? labelmapData.imageIds.map((imageId) => cache.getImage(imageId))
+                : [cache.getVolume(labelmapData.volumeId)];
+            items.forEach((item) => {
+                if (!item) {
+                    return;
+                }
+                const { voxelManager } = item;
+                voxelManager.forEach(({ value, index }) => {
+                    if (value === segmentIndex) {
+                        voxelManager.setAtIndex(index, 0);
+                    }
+                });
+            });
+        }
+        triggerSegmentationDataModified(segmentationId);
+    }
+    else {
+        throw new Error('Invalid segmentation type, only labelmap is supported right now');
+    }
+}

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

@@ -11,7 +11,6 @@ export type SurfaceClipResult = {
     numberOfCells: number;
 };
 export type PolyDataClipCacheType = Map<string, Map<string, SurfaceClipResult>>;
-export declare function clipAndCacheSurfacesForViewport(surfacesInfo: SurfacesInfo[], viewport: Types.IVolumeViewport, segmentationRepresentationUID: string): Promise<PolyDataClipCacheType>;
-export declare function getSurfaceActorUID(segmentationRepresentationUID: string, surfaceId: string): string;
+export declare function clipAndCacheSurfacesForViewport(surfacesInfo: SurfacesInfo[], viewport: Types.IVolumeViewport, segmentationId: string): Promise<PolyDataClipCacheType>;
 export declare function generateCacheId(viewport: any, viewPlaneNormal: any, sliceIndex: any): string;
 export declare function updatePolyDataCache(actorUID: string, cacheId: string, polyDataResult: SurfaceClipResult): void;

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

@@ -2,6 +2,7 @@ import { Enums, getWebWorkerManager, eventTarget, triggerEvent, } from '@corners
 import { WorkerTypes } from '../../../enums';
 import { pointToString } from '../../../utilities/pointToString';
 import { registerPolySegWorker } from '../polySeg/registerPolySegWorker';
+import { getSurfaceActorUID } from './getSegmentationActor';
 const workerManager = getWebWorkerManager();
 const polyDataCache = new Map();
 const surfacesAABBCache = new Map();
@@ -11,7 +12,7 @@ const triggerWorkerProgress = (eventTarget, progress) => {
         type: WorkerTypes.SURFACE_CLIPPING,
     });
 };
-export async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID) {
+export async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationId) {
     registerPolySegWorker();
     const planesInfo = viewport.getSlicesClippingPlanes?.();
     if (!planesInfo) {
@@ -41,8 +42,8 @@ export async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport, se
                 triggerWorkerProgress(eventTarget, progress);
             },
             ({ sliceIndex, polyDataResults }) => {
-                polyDataResults.forEach((polyDataResult, surfaceId) => {
-                    const actorUID = `${segmentationRepresentationUID}_${surfaceId}`;
+                polyDataResults.forEach((polyDataResult) => {
+                    const actorUID = getSurfaceActorUID(segmentationId);
                     const cacheId = generateCacheId(viewport, camera.viewPlaneNormal, sliceIndex);
                     updatePolyDataCache(actorUID, cacheId, polyDataResult);
                 });
@@ -73,9 +74,6 @@ async function updateSurfacesAABBCache(surfacesInfo) {
         surfacesAABBCache.set(id, aabb);
     });
 }
-export function getSurfaceActorUID(segmentationRepresentationUID, surfaceId) {
-    return `${segmentationRepresentationUID}_${surfaceId}`;
-}
 export function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
     return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
 }
@@ -88,4 +86,3 @@ export function updatePolyDataCache(actorUID, cacheId, polyDataResult) {
     }
     actorCache.set(cacheId, { points, lines, numberOfCells });
 }
-//# sourceMappingURL=clipAndCacheSurfacesForViewport.js.map

package/dist/esm/stateManagement/segmentation/{convertVolumeToStackSegmentation.d.ts → helpers/computeStackLabelmapFromVolume.d.ts}

@@ -1,9 +1,9 @@
-export declare function computeStackSegmentationFromVolume({ volumeId, }: {
+export declare function computeStackLabelmapFromVolume({ volumeId, }: {
     volumeId: string;
 }): Promise<{
     imageIds: string[];
 }>;
-export declare function convertVolumeToStackSegmentation({ segmentationId, options, }: {
+export declare function convertVolumeToStackLabelmap({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
         viewportId: string;

package/dist/esm/stateManagement/segmentation/{convertVolumeToStackSegmentation.js → helpers/computeStackLabelmapFromVolume.js}

@@ -1,20 +1,22 @@
 import { cache } from '@cornerstonejs/core';
-import { getSegmentation } from './getSegmentation';
-import { updateStackSegmentationState } from './helpers/updateStackSegmentationState';
-export async function computeStackSegmentationFromVolume({ volumeId, }) {
+import { getSegmentation } from '../getSegmentation';
+import { updateStackSegmentationState } from '../helpers/updateStackSegmentationState';
+export async function computeStackLabelmapFromVolume({ volumeId, }) {
     const segmentationVolume = cache.getVolume(volumeId);
     return { imageIds: segmentationVolume.imageIds };
 }
-export async function convertVolumeToStackSegmentation({ segmentationId, options, }) {
+export function convertVolumeToStackLabelmap({ segmentationId, options, }) {
     const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
     const { volumeId } = segmentation.representationData
         .Labelmap;
     const segmentationVolume = cache.getVolume(volumeId);
-    await updateStackSegmentationState({
+    return updateStackSegmentationState({
         segmentationId,
         viewportId: options.viewportId,
         imageIds: segmentationVolume.imageIds,
         options,
     });
 }
-//# sourceMappingURL=convertVolumeToStackSegmentation.js.map

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

@@ -0,0 +1,3 @@
+export declare function computeVolumeLabelmapFromStack(args: any): Promise<{
+    volumeId: string;
+}>;

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

@@ -0,0 +1,4 @@
+import { internalComputeVolumeLabelmapFromStack } from '../SegmentationStateManager';
+export async function computeVolumeLabelmapFromStack(args) {
+    return internalComputeVolumeLabelmapFromStack(args);
+}

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

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

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/normalizeSegmentationInput.js

@@ -1,13 +1,12 @@
 import { SegmentationRepresentations } from '../../../enums';
 function normalizeSegmentationInput(segmentationInput) {
     const { segmentationId, representation } = segmentationInput;
-    const isContourRepresentation = representation.type === SegmentationRepresentations.Contour;
-    let data = representation.data ? { ...representation.data } : null;
-    data = !data && isContourRepresentation ? {} : data;
+    const { type, data: inputData } = representation;
+    const data = inputData ? { ...inputData } : {};
     if (!data) {
         throw new Error('Segmentation representation data may not be undefined');
     }
-    if (isContourRepresentation) {
+    if (type === SegmentationRepresentations.Contour) {
         const contourData = data;
         contourData.geometryIds = contourData.geometryIds ?? [];
         contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
@@ -18,14 +17,12 @@ function normalizeSegmentationInput(segmentationInput) {
         segmentLabels: {},
         label: null,
         segmentsLocked: new Set(),
-        type: representation.type,
         activeSegmentIndex: 1,
         representationData: {
-            [representation.type]: {
+            [type]: {
                 ...data,
             },
         },
     };
 }
 export default normalizeSegmentationInput;
-//# sourceMappingURL=normalizeSegmentationInput.js.map

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

@@ -2,7 +2,7 @@ import { cache, eventTarget } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../../enums';
 import { getSegmentation } from '../getSegmentation';
 import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
-import { addSegmentationRepresentations } from '../addSegmentationRepresentations';
+import { addSegmentationRepresentations } from '../addSegmentationRepresentationsToViewport';
 export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
     const segmentation = getSegmentation(segmentationId);
     if (options?.removeOriginal) {
@@ -29,4 +29,3 @@ export async function updateStackSegmentationState({ segmentationId, viewportId,
     ]);
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
-//# sourceMappingURL=updateStackSegmentationState.js.map

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

@@ -18,4 +18,3 @@ function validateSegmentationInput(segmentationInputArray) {
     });
 }
 export default validateSegmentationInput;
-//# sourceMappingURL=validateSegmentationInput.js.map

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

@@ -1,14 +1,21 @@
-import removeSegmentationRepresentations from './removeSegmentationRepresentations';
-import addSegmentations from './addSegmentations';
-import { addSegmentationRepresentations, addMultiViewportSegmentationRepresentations } from './addSegmentationRepresentations';
-import addRepresentationData from './addRepresentationData';
-import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
 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';
-import { convertStackToVolumeSegmentation } from './SegmentationStateManager';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, addMultiViewportSegmentationRepresentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+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, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, };

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

@@ -1,15 +1,21 @@
-import removeSegmentationRepresentations from './removeSegmentationRepresentations';
-import addSegmentations from './addSegmentations';
-import { addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, } from './addSegmentationRepresentations';
-import addRepresentationData from './addRepresentationData';
-import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
 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';
-import { convertStackToVolumeSegmentation } from './SegmentationStateManager';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, addMultiViewportSegmentationRepresentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
-//# sourceMappingURL=index.js.map
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+const helpers = {
+    clearSegmentValue,
+    convertStackToVolumeLabelmap,
+    computeVolumeLabelmapFromStack,
+    convertVolumeToStackLabelmap,
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, };

package/dist/esm/stateManagement/segmentation/{addRepresentationData.d.ts → internalAddRepresentationData.d.ts}

@@ -8,5 +8,5 @@ type AddRepresentationData = {
     type: SegmentationRepresentations;
     data: SegmentationData;
 };
-declare function addRepresentationData({ segmentationId, type, data, }: AddRepresentationData): void;
-export default addRepresentationData;
+declare function internalAddRepresentationData({ segmentationId, type, data, }: AddRepresentationData): void;
+export default internalAddRepresentationData;

package/dist/esm/stateManagement/segmentation/{addRepresentationData.js → internalAddRepresentationData.js}

@@ -1,7 +1,10 @@
 import { getSegmentation } from './getSegmentation';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-function addRepresentationData({ segmentationId, type, data, }) {
+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.`);
     }
@@ -26,5 +29,4 @@ function addRepresentationData({ segmentationId, type, data, }) {
             throw new Error(`Invalid representation type ${type}`);
     }
 }
-export default addRepresentationData;
-//# sourceMappingURL=addRepresentationData.js.map
+export default internalAddRepresentationData;

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

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