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

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/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/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,5 +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];
 }

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,5 +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);
 }

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

@@ -2,9 +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;
 }

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}`;
 }

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,16 +1,19 @@
 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,

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,2 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-export { validateSegmentationInput };
+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,10 +17,9 @@ function normalizeSegmentationInput(segmentationInput) {
         segmentLabels: {},
         label: null,
         segmentsLocked: new Set(),
-        type: representation.type,
         activeSegmentIndex: 1,
         representationData: {
-            [representation.type]: {
+            [type]: {
                 ...data,
             },
         },

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) {

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,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';
+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,4 +29,4 @@ function addRepresentationData({ segmentationId, type, data, }) {
             throw new Error(`Invalid representation type ${type}`);
     }
 }
-export default addRepresentationData;
+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 };

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

@@ -1,73 +1,33 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { utilities } from '@cornerstonejs/core';
 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 { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
-import { addSegmentationRepresentationState } from './addSegmentationRepresentationState';
-function getLabelmapSegmentationRepresentationRenderingConfig() {
-    const cfun = vtkColorTransferFunction.newInstance();
-    const ofun = vtkPiecewiseFunction.newInstance();
-    ofun.addPoint(0, 0);
-    return {
-        ofun,
-        cfun,
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getColorLUT } from './getColorLUT';
+function internalAddSegmentationRepresentation(viewportId, representationInput) {
+    const { segmentationId, config } = representationInput;
+    const renderingConfig = {
+        colorLUTIndex: getColorLUTIndex(config),
     };
-}
-async function internalAddSegmentationRepresentation(viewportId, representationInput) {
-    const { segmentationId, options = {} } = representationInput;
-    const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
-        utilities.uuidv4();
-    const colorLUTIndexToUse = getColorLUTIndex(options);
-    const { type } = representationInput;
-    let renderingConfig;
-    if (type === SegmentationRepresentations.Labelmap) {
-        renderingConfig = getLabelmapSegmentationRepresentationRenderingConfig();
-    }
-    else {
-        renderingConfig = {};
-    }
-    const representation = {
-        segmentationId,
-        segmentationRepresentationUID,
-        type: representationInput.type,
-        colorLUTIndex: colorLUTIndexToUse,
-        rendering: renderingConfig,
-        polySeg: options.polySeg,
-        config: {
-            allSegments: {},
-            perSegment: {},
-        },
-    };
-    addSegmentationRepresentationState(viewportId, representation);
-    const initialConfig = representationInput.config;
-    if (initialConfig) {
-        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig);
-    }
+    defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
     }
     triggerSegmentationModified(segmentationId);
-    return segmentationRepresentationUID;
 }
-function getColorLUTIndex(options = {}) {
-    const colorLUTOrIndexInput = options.colorLUTOrIndex;
-    let colorLUTIndexToUse;
-    if (typeof colorLUTOrIndexInput === 'number') {
-        colorLUTIndexToUse = colorLUTOrIndexInput;
-    }
-    else {
-        const nextIndex = getNextColorLUTIndex();
-        const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
-            ? colorLUTOrIndexInput
-            : CORNERSTONE_COLOR_LUT;
-        addColorLUT(colorLUTToAdd, nextIndex);
-        colorLUTIndexToUse = nextIndex;
+function getColorLUTIndex(config) {
+    const colorLUT = config?.colorLUT;
+    const nextIndex = getNextColorLUTIndex();
+    const colorLUTToAdd = Array.isArray(colorLUT)
+        ? colorLUT
+        : CORNERSTONE_COLOR_LUT;
+    addColorLUT(colorLUTToAdd, nextIndex);
+    const colorLUTIndex = nextIndex;
+    if (!getColorLUT(colorLUTIndex)) {
+        throw new Error(`Color LUT with index ${colorLUTIndex} not found`);
     }
-    return colorLUTIndexToUse;
+    return colorLUTIndex;
 }
 export { internalAddSegmentationRepresentation };

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

@@ -5,7 +5,8 @@ import { clipAndCacheSurfacesForViewport } from '../../helpers/clipAndCacheSurfa
 import { extractContourData } from './utils/extractContourData';
 import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
 import { getSegmentation } from '../../getSegmentation';
-import { setSegmentationRepresentationConfig } from '../../setSegmentationRepresentationConfig';
+import { segmentationStyle } from '../../SegmentationStyle';
+import { SegmentationRepresentations } from '../../../../enums';
 export async function computeContourData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -34,12 +35,10 @@ export async function computeContourData(segmentationId, options = {}) {
     if (!rawContourData) {
         throw new Error('Not enough data to convert to contour, currently only support converting volume labelmap to contour if available');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    setSegmentationRepresentationConfig(segmentationRepresentationUID, {
-        Contour: {
-            fillAlpha: 0,
-        },
+    segmentationStyle.setSegmentationSpecificStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
+        fillAlpha: 0,
     });
     return {
         annotationUIDsMap,
@@ -54,7 +53,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
         console.error('Failed to convert labelmap to surface or labelmap is empty');
         return;
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const pointsAndPolys = results.map((surface) => {
         return {
             id: surface.segmentIndex.toString(),
@@ -63,7 +62,7 @@ async function computeContourFromLabelmapSegmentation(segmentationId, options =
             segmentIndex: surface.segmentIndex,
         };
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationRepresentationUID);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(pointsAndPolys, viewport, segmentationId);
     const rawResults = extractContourData(polyDataCache);
     return rawResults;
 }
@@ -71,7 +70,7 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     if (!options.viewport) {
         throw new Error('Viewport is required to compute contour from surface');
     }
-    const { viewport, segmentationRepresentationUID } = options;
+    const { viewport } = options;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
@@ -96,7 +95,7 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
         surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
     });
-    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationRepresentationUID);
+    const polyDataCache = await clipAndCacheSurfacesForViewport(surfacesInfo, viewport, segmentationId);
     const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
     return rawResults;
 }

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

@@ -1,15 +1,18 @@
 export function extractContourData(polyDataCache, segmentIndexMap) {
     const rawResults = new Map();
     for (const [cacheId, intersectionInfo] of polyDataCache) {
-        const surfaceId = cacheId.split('_')[1];
+        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;
             }
-            const segmentIndex = Number(surfaceId) || segmentIndexMap?.get(surfaceId);
-            if (!segmentIndex) {
-                continue;
-            }
             if (!rawResults.has(segmentIndex)) {
                 rawResults.set(segmentIndex, []);
             }