@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,10 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationRemoved(viewportId, segmentationId, type) {
+    const eventDetail = {
+        viewportId,
+        segmentationId,
+        type,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
+}

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

@@ -0,0 +1 @@
+export declare function getActiveSegmentIndex(segmentationId: string): number | undefined;

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

@@ -0,0 +1,9 @@
+import { getSegmentation } from './getSegmentation';
+export function getActiveSegmentIndex(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (segmentation) {
+        const activeSegmentIndex = Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active);
+        return activeSegmentIndex ? Number(activeSegmentIndex) : undefined;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getActiveSegmentation(viewportId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getActiveSegmentation(viewportId);
+}

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getColorLUT(index: number): Types.ColorLUT | undefined;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getColorLUT(index) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getColorLUT(index);
+}

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

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

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
+}

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.getStyle({ type });
+}

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

@@ -0,0 +1 @@
+export declare function getLabelmapImageIds(segmentationId: string): string | undefined;

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

@@ -0,0 +1,7 @@
+import { getSegmentation } from './getSegmentation';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getLabelmapImageIds(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const segmentation = getSegmentation(segmentationId);
+    return segmentationStateManager.getLabelmapImageIds(segmentation.representationData);
+}

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

@@ -0,0 +1 @@
+export declare function getNextColorLUTIndex(): number;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getNextColorLUTIndex() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getNextColorLUTIndex();
+}

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

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

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentation(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentation(segmentationId);
+}

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

@@ -0,0 +1,14 @@
+import type { SegmentationRepresentations } from '../../enums';
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+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;
+export declare function getSegmentationRepresentationsBySegmentationId(segmentationId: string): {
+    viewportId: string;
+    representations: SegmentationRepresentation[];
+}[];

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

@@ -0,0 +1,17 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentations(viewportId, specifier = {}) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    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];
+}
+export function getSegmentationRepresentationsBySegmentationId(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentationsBySegmentationId(segmentationId);
+}

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

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

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentationVisibility(viewportId, specifier) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, specifier);
+}

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

@@ -0,0 +1,2 @@
+import type { Segmentation } from '../../types';
+export declare function getSegmentations(): Segmentation[] | [];

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

@@ -0,0 +1,6 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentations() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    return state.segmentations;
+}

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

@@ -0,0 +1 @@
+export declare function getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getStackSegmentationImageIdsForViewport(viewportId, segmentationId);
+}

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

@@ -0,0 +1 @@
+export declare function getViewportIdsWithSegmentation(segmentationId: string): string[];

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

@@ -0,0 +1,10 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getViewportIdsWithSegmentation(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    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,30 @@
+import { cache } from '@cornerstonejs/core';
+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/computeStackLabelmapFromVolume.d.ts

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

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

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

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,6 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getLabelmapActorUID(viewportId: string, segmentationId: string): string | undefined;
+export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string): Types.ActorEntry;
+export declare function getSurfaceActorEntry(viewportId: string, segmentationId: string, segmentIndex?: number | string): Types.ActorEntry;
+export declare function getSurfaceActorUID(viewportId: string, segmentationId: string, segmentIndex?: number | string): string | undefined;
+export declare function getSurfaceRepresentationUID(segmentationId: string, segmentIndex?: number | string): string;

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

@@ -0,0 +1,34 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../../enums';
+function getActorEntry(viewportId, segmentationId, filterFn) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { renderingEngine, viewport } = enabledElement;
+    if (!renderingEngine || !viewport) {
+        return;
+    }
+    const actors = viewport.getActors();
+    const filteredActors = actors.filter(filterFn);
+    return filteredActors.length > 0 ? filteredActors[0] : undefined;
+}
+export function getLabelmapActorUID(viewportId, segmentationId) {
+    const actorEntry = getLabelmapActorEntry(viewportId, segmentationId);
+    return actorEntry?.uid;
+}
+export function getLabelmapActorEntry(viewportId, segmentationId) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
+}
+export function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID ===
+        getSurfaceRepresentationUID(segmentationId, segmentIndex));
+}
+export function getSurfaceActorUID(viewportId, segmentationId, segmentIndex) {
+    const segIndex = segmentIndex ? segmentIndex.toString() : '';
+    const actorEntry = getSurfaceActorEntry(viewportId, segmentationId, segIndex);
+    return actorEntry?.uid;
+}
+export function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
+    return `${segmentationId}-${SegmentationRepresentations.Surface}-${segmentIndex}`;
+}

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

@@ -0,0 +1,3 @@
+import validateSegmentationInput from './validateSegmentationInput';
+import { getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };

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

@@ -0,0 +1,3 @@
+import validateSegmentationInput from './validateSegmentationInput';
+import { getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };

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

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

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

@@ -0,0 +1,71 @@
+import { SegmentationRepresentations } from '../../../enums';
+import { cache } from '@cornerstonejs/core';
+function normalizeSegmentationInput(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) {
+        normalizeContourData(data);
+    }
+    const normalizedSegments = normalizeSegments(config?.segments, type, data);
+    delete config?.segments;
+    return {
+        segmentationId,
+        label: config?.label ?? null,
+        cachedStats: config?.cachedStats ?? {},
+        segments: normalizedSegments,
+        representationData: {
+            [type]: {
+                ...data,
+            },
+        },
+    };
+}
+function normalizeContourData(contourData) {
+    contourData.geometryIds = contourData.geometryIds ?? [];
+    contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
+}
+function normalizeSegments(segmentsConfig, type, data) {
+    const normalizedSegments = {};
+    if (segmentsConfig) {
+        Object.entries(segmentsConfig).forEach(([segmentIndex, segment]) => {
+            normalizedSegments[segmentIndex] = {
+                segmentIndex: Number(segmentIndex),
+                label: segment.label ?? `Segment ${segmentIndex}`,
+                locked: segment.locked ?? false,
+                cachedStats: segment.cachedStats ?? {},
+                active: segment.active ?? false,
+            };
+        });
+    }
+    else if (type === SegmentationRepresentations.Surface) {
+        normalizeSurfaceSegments(normalizedSegments, data);
+    }
+    else {
+        normalizedSegments[1] = createDefaultSegment();
+    }
+    return normalizedSegments;
+}
+function normalizeSurfaceSegments(normalizedSegments, surfaceData) {
+    const { geometryIds } = surfaceData;
+    geometryIds?.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (geometry?.data) {
+            const { segmentIndex } = geometry.data;
+            normalizedSegments[segmentIndex] = { segmentIndex };
+        }
+    });
+}
+function createDefaultSegment() {
+    return {
+        segmentIndex: 1,
+        label: 'Segment 1',
+        locked: false,
+        cachedStats: {},
+        active: true,
+    };
+}
+export default normalizeSegmentationInput;

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

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

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

@@ -0,0 +1,20 @@
+import * as Enums from '../../../enums';
+import { validatePublic as validatePublicLabelmap } from '../../../utilities/segmentation/validateLabelmap';
+function validateSegmentationInput(segmentationInputArray) {
+    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('Undefined segmentationInput.segmentationId. Please provide a valid segmentationId');
+        }
+        if (segmentationInput.representation === undefined) {
+            throw new Error('Undefined segmentationInput.representation. Please provide a valid representation');
+        }
+        if (segmentationInput.representation.type ===
+            Enums.SegmentationRepresentations.Labelmap) {
+            validatePublicLabelmap(segmentationInput);
+        }
+    });
+}
+export default validateSegmentationInput;

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

@@ -0,0 +1,28 @@
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import addRepresentationData from './internalAddRepresentationData';
+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';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+import { getLabelmapImageIds } from './getLabelmapImageIds';
+import * as strategies from './../../tools/segmentation/strategies';
+import { removeAllSegmentations, removeSegmentation } from './removeSegmentation';
+import { segmentationStyle } from './SegmentationStyle';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+declare const helpers: {
+    clearSegmentValue: typeof clearSegmentValue;
+    convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
+    computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
+    convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };

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

@@ -0,0 +1,28 @@
+import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
+import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
+import { addSegmentations } from './addSegmentations';
+import addRepresentationData from './internalAddRepresentationData';
+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';
+import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
+import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
+import { getLabelmapImageIds } from './getLabelmapImageIds';
+import * as strategies from './../../tools/segmentation/strategies';
+import { removeAllSegmentations, removeSegmentation, } from './removeSegmentation';
+import { segmentationStyle } from './SegmentationStyle';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+const helpers = {
+    clearSegmentValue,
+    convertStackToVolumeLabelmap,
+    computeVolumeLabelmapFromStack,
+    convertVolumeToStackLabelmap,
+};
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };

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;