@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapLayerStore.js

@@ -0,0 +1,160 @@
+import { cache, imageLoader, volumeLoader } from '@cornerstonejs/core';
+import { ensureLabelmapState } from './normalizeLabelmapSegmentationData';
+import { forEachLabelmapImageReference, hasMultipleLabelmapImagesPerReferencedImageId, } from './labelmapImageIdMapping';
+function getLabelmap(segmentation, labelmapId) {
+    return ensureLabelmapState(segmentation)?.labelmaps?.[labelmapId];
+}
+function getLabelmaps(segmentation) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return [];
+    }
+    return Object.values(labelmapState.labelmaps);
+}
+function registerLabelmap(segmentation, layer) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    labelmapState.labelmaps[layer.labelmapId] = layer;
+}
+function removeLabelmap(segmentation, labelmapId) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const layer = labelmapState.labelmaps[labelmapId];
+    if (layer?.geometryVolumeId && cache.getVolume(layer.geometryVolumeId)) {
+        cache.removeVolumeLoadObject(layer.geometryVolumeId);
+    }
+    delete labelmapState.labelmaps[labelmapId];
+}
+function getOrCreateLabelmapVolume(layer) {
+    const mergedVolume = getOrCreateMergedStackLabelmapVolume(layer);
+    if (mergedVolume) {
+        return mergedVolume;
+    }
+    const existingVolumeId = layer.volumeId ?? layer.geometryVolumeId;
+    if (existingVolumeId) {
+        const cachedVolume = cache.getVolume(existingVolumeId);
+        if (cachedVolume) {
+            return cachedVolume;
+        }
+    }
+    const imageIds = layer.imageIds ?? [];
+    if (!imageIds.length) {
+        return;
+    }
+    const volumeId = layer.volumeId ?? layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
+    if (!layer.volumeId) {
+        layer.geometryVolumeId = volumeId;
+    }
+    const cachedVolume = cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
+    }
+    return volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, imageIds);
+}
+function getOrCreateMergedStackLabelmapVolume(layer) {
+    if (layer.volumeId || !hasDuplicateReferencedImageIds(layer)) {
+        return;
+    }
+    const volumeId = layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
+    const cachedVolume = cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
+    }
+    const imageIdsByReferencedImageId = new Map();
+    forEachLabelmapImageReference(layer, (referencedImageId, imageId) => {
+        const imageIdsForReference = imageIdsByReferencedImageId.get(referencedImageId) ?? [];
+        imageIdsForReference.push(imageId);
+        imageIdsByReferencedImageId.set(referencedImageId, imageIdsForReference);
+    });
+    const mergedReferencedImageIds = Array.from(imageIdsByReferencedImageId.keys());
+    if (!mergedReferencedImageIds.length) {
+        return;
+    }
+    let mergedImageIndex = 0;
+    const mergedImages = imageLoader.createAndCacheDerivedImages(mergedReferencedImageIds, {
+        getDerivedImageId: () => `${volumeId}-image-${mergedImageIndex++}`,
+        targetBuffer: { type: 'Uint8Array' },
+    });
+    mergedImages.forEach((mergedImage) => {
+        const sourceImageIds = imageIdsByReferencedImageId.get(mergedImage.referencedImageId);
+        if (!sourceImageIds?.length) {
+            return;
+        }
+        const targetVoxelManager = mergedImage.voxelManager;
+        const scalarDataLength = targetVoxelManager.getScalarDataLength();
+        sourceImageIds.forEach((sourceImageId) => {
+            const sourceImage = cache.getImage(sourceImageId);
+            const sourceVoxelManager = sourceImage?.voxelManager;
+            if (!sourceVoxelManager) {
+                return;
+            }
+            const sourceScalarDataLength = sourceVoxelManager.getScalarDataLength();
+            const length = Math.min(scalarDataLength, sourceScalarDataLength);
+            for (let index = 0; index < length; index++) {
+                const value = Number(sourceVoxelManager.getAtIndex(index));
+                if (value !== 0) {
+                    targetVoxelManager.setAtIndex(index, value);
+                }
+            }
+        });
+    });
+    layer.geometryVolumeId = volumeId;
+    return volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, mergedImages.map((image) => image.imageId));
+}
+function hasDuplicateReferencedImageIds(layer) {
+    return hasMultipleLabelmapImagesPerReferencedImageId(layer);
+}
+function getLabelmapIds(segmentation) {
+    return getLabelmaps(segmentation).map((layer) => layer.labelmapId);
+}
+function getLabelmapDataById(segmentation, labelmapId) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    const layer = labelmapState?.labelmaps?.[labelmapId];
+    if (!labelmapState || !layer) {
+        return;
+    }
+    return {
+        volumeId: layer.volumeId,
+        referencedVolumeId: layer.referencedVolumeId,
+        imageIds: layer.imageIds,
+        referencedImageIds: layer.referencedImageIds,
+        sourceRepresentationName: labelmapState.sourceRepresentationName,
+        primaryLabelmapId: labelmapId,
+        labelmaps: {
+            [labelmapId]: layer,
+        },
+        segmentBindings: Object.fromEntries(Object.entries(labelmapState.segmentBindings).filter(([, binding]) => binding.labelmapId === labelmapId)),
+    };
+}
+function getScalarArrayLengthFromLabelmap(layer) {
+    if (layer.volumeId) {
+        return cache.getVolume(layer.volumeId)?.voxelManager?.getScalarDataLength();
+    }
+    const firstImageId = layer.imageIds?.[0];
+    const firstImage = firstImageId ? cache.getImage(firstImageId) : null;
+    if (!firstImage || !layer.imageIds?.length) {
+        return 0;
+    }
+    return firstImage.voxelManager.getScalarDataLength() * layer.imageIds.length;
+}
+function getConstructorNameForLabelmap(layer) {
+    if (layer.volumeId) {
+        return cache.getVolume(layer.volumeId)?.voxelManager?.getConstructor()
+            ?.name;
+    }
+    const imageId = layer.imageIds?.[0];
+    return imageId
+        ? cache.getImage(imageId)?.voxelManager?.getConstructor()?.name
+        : undefined;
+}
+function getLabelmapForImageId(segmentation, imageId) {
+    return getLabelmaps(segmentation).find((layer) => layer.imageIds?.includes(imageId));
+}
+function getLabelmapForVolumeId(segmentation, volumeId) {
+    return getLabelmaps(segmentation).find((layer) => layer.volumeId === volumeId || layer.geometryVolumeId === volumeId);
+}
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapLegacyAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+declare function syncLegacyLabelmapData(segmentation: Segmentation): void;
+declare function getReferencedImageIdToCurrentImageIdMap(segmentation: Segmentation): Map<string, string[]>;
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapLegacyAdapter.js

@@ -0,0 +1,42 @@
+import { ensureLabelmapState, getSegmentOrder, } from './normalizeLabelmapSegmentationData';
+import { getLabelmaps } from './labelmapLayerStore';
+import { forEachLabelmapImageReference } from './labelmapImageIdMapping';
+function syncOptionalLegacyProperty(target, key, value) {
+    if (value == null) {
+        delete target[key];
+        return;
+    }
+    target[key] = value;
+}
+function syncLegacyLabelmapData(segmentation) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const firstSegmentIndex = getSegmentOrder(segmentation)[0] ?? 1;
+    const primaryLabelmapId = labelmapState.primaryLabelmapId ??
+        labelmapState.segmentBindings[firstSegmentIndex]?.labelmapId ??
+        Object.keys(labelmapState.labelmaps)[0];
+    const primaryLayer = labelmapState.labelmaps[primaryLabelmapId];
+    if (!primaryLayer) {
+        return;
+    }
+    syncOptionalLegacyProperty(labelmapState, 'volumeId', primaryLayer.volumeId);
+    syncOptionalLegacyProperty(labelmapState, 'referencedVolumeId', primaryLayer.referencedVolumeId);
+    syncOptionalLegacyProperty(labelmapState, 'imageIds', primaryLayer.imageIds);
+    syncOptionalLegacyProperty(labelmapState, 'referencedImageIds', primaryLayer.referencedImageIds);
+}
+function getReferencedImageIdToCurrentImageIdMap(segmentation) {
+    const map = new Map();
+    getLabelmaps(segmentation).forEach((layer) => {
+        forEachLabelmapImageReference(layer, (referenceImageId, labelmapImageId) => {
+            const values = map.get(referenceImageId) ?? [];
+            if (!values.includes(labelmapImageId)) {
+                values.push(labelmapImageId);
+            }
+            map.set(referenceImageId, values);
+        });
+    });
+    return map;
+}
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapSegmentBindings.d.ts

@@ -0,0 +1,11 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer, SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+declare function getSegmentBinding(segmentation: Segmentation, segmentIndex: number): SegmentLabelmapBindingState | undefined;
+declare function setSegmentBinding(segmentation: Segmentation, segmentIndex: number, binding: SegmentLabelmapBindingState): void;
+declare function getSegmentsOnLabelmap(segmentation: Segmentation, labelmapId: string): number[];
+declare function getSegmentIndexForLabelValue(segmentation: Segmentation, labelmapId: string, labelValue: number): number | undefined;
+declare function getLabelValueForSegment(segmentation: Segmentation, segmentIndex: number): number;
+declare function getLabelmapForSegment(segmentation: Segmentation, segmentIndex: number): LabelmapLayer | undefined;
+declare function resolveLabelmapForSegment(segmentation: Segmentation, segmentIndex: number): LabelmapLayer | undefined;
+declare function removeSegmentBinding(segmentation: Segmentation, segmentIndex: number): void;
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapSegmentBindings.js

@@ -0,0 +1,73 @@
+import { ensureLabelmapState } from './normalizeLabelmapSegmentationData';
+import { getLabelmap, getLabelmaps, removeLabelmap, } from './labelmapLayerStore';
+import { syncLegacyLabelmapData } from './labelmapLegacyAdapter';
+function getSegmentBinding(segmentation, segmentIndex) {
+    return ensureLabelmapState(segmentation)?.segmentBindings?.[segmentIndex];
+}
+function setSegmentBinding(segmentation, segmentIndex, binding) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const previousBinding = labelmapState.segmentBindings[segmentIndex];
+    if (previousBinding) {
+        const previousLayer = labelmapState.labelmaps[previousBinding.labelmapId];
+        if (previousLayer?.labelToSegmentIndex) {
+            delete previousLayer.labelToSegmentIndex[previousBinding.labelValue];
+        }
+    }
+    labelmapState.segmentBindings[segmentIndex] = binding;
+    const layer = labelmapState.labelmaps[binding.labelmapId];
+    if (layer) {
+        layer.labelToSegmentIndex ||= {};
+        layer.labelToSegmentIndex[binding.labelValue] = segmentIndex;
+    }
+}
+function getSegmentsOnLabelmap(segmentation, labelmapId) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    if (!labelmapState) {
+        return [];
+    }
+    return Object.entries(labelmapState.segmentBindings)
+        .filter(([, binding]) => binding.labelmapId === labelmapId)
+        .map(([segmentIndex]) => Number(segmentIndex))
+        .sort((a, b) => a - b);
+}
+function getSegmentIndexForLabelValue(segmentation, labelmapId, labelValue) {
+    const layer = getLabelmap(segmentation, labelmapId);
+    if (!layer || labelValue == null) {
+        return;
+    }
+    return layer.labelToSegmentIndex?.[labelValue] ?? labelValue;
+}
+function getLabelValueForSegment(segmentation, segmentIndex) {
+    return (getSegmentBinding(segmentation, segmentIndex)?.labelValue ?? segmentIndex);
+}
+function getLabelmapForSegment(segmentation, segmentIndex) {
+    const binding = getSegmentBinding(segmentation, segmentIndex);
+    if (!binding) {
+        return;
+    }
+    return getLabelmap(segmentation, binding.labelmapId);
+}
+function resolveLabelmapForSegment(segmentation, segmentIndex) {
+    return (getLabelmapForSegment(segmentation, segmentIndex) ??
+        getLabelmaps(segmentation)[0]);
+}
+function removeSegmentBinding(segmentation, segmentIndex) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    const binding = labelmapState?.segmentBindings?.[segmentIndex];
+    if (!labelmapState || !binding) {
+        return;
+    }
+    const layer = labelmapState.labelmaps[binding.labelmapId];
+    if (layer?.labelToSegmentIndex) {
+        delete layer.labelToSegmentIndex[binding.labelValue];
+    }
+    delete labelmapState.segmentBindings[segmentIndex];
+    if (getSegmentsOnLabelmap(segmentation, binding.labelmapId).length === 0) {
+        removeLabelmap(segmentation, binding.labelmapId);
+    }
+    syncLegacyLabelmapData(segmentation);
+}
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, };

package/dist/esm/stateManagement/segmentation/labelmapModel/normalizeLabelmapSegmentationData.d.ts

@@ -0,0 +1,17 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapSegmentationData, LabelmapLayer, SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+declare const SOURCE_REPRESENTATION_NAME = "binaryLabelmap";
+type LabelmapSegmentationWithState = LabelmapSegmentationData & {
+    labelmaps: {
+        [labelmapId: string]: LabelmapLayer;
+    };
+    segmentBindings: {
+        [segmentIndex: number]: SegmentLabelmapBindingState;
+    };
+    primaryLabelmapId: string;
+};
+declare function getSegmentOrder(segmentation: Segmentation): number[];
+declare function getPrimaryLabelmapId(segmentationId: string): string;
+declare function ensureLabelmapState(segmentation: Segmentation): LabelmapSegmentationWithState | undefined;
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, };
+export type { LabelmapSegmentationWithState };

package/dist/esm/stateManagement/segmentation/labelmapModel/normalizeLabelmapSegmentationData.js

@@ -0,0 +1,75 @@
+const SOURCE_REPRESENTATION_NAME = 'binaryLabelmap';
+function getSegmentOrder(segmentation) {
+    if (segmentation.segmentOrder?.length) {
+        return [...segmentation.segmentOrder];
+    }
+    return Object.keys(segmentation.segments)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+function getPrimaryLabelmapId(segmentationId) {
+    return `${segmentationId}-storage-0`;
+}
+function getPrimaryLabelmapType(labelmapData) {
+    return labelmapData.volumeId ? 'volume' : 'stack';
+}
+function createPrimaryLabelmapLayer(segmentation, labelmapData, labelmapId = getPrimaryLabelmapId(segmentation.segmentationId)) {
+    const layer = {
+        labelmapId,
+        type: getPrimaryLabelmapType(labelmapData),
+        labelToSegmentIndex: {},
+    };
+    if (labelmapData.volumeId != null) {
+        layer.volumeId = labelmapData.volumeId;
+    }
+    if (labelmapData.referencedVolumeId != null) {
+        layer.referencedVolumeId = labelmapData.referencedVolumeId;
+    }
+    if (labelmapData.referencedImageIds != null) {
+        layer.referencedImageIds = labelmapData.referencedImageIds;
+    }
+    if (labelmapData.imageIds != null) {
+        layer.imageIds = labelmapData.imageIds;
+    }
+    return layer;
+}
+function resolvePrimaryLabelmapId(segmentation, labelmapData) {
+    const storedLabelmapId = labelmapData.primaryLabelmapId;
+    if (storedLabelmapId && labelmapData.labelmaps?.[storedLabelmapId]) {
+        return storedLabelmapId;
+    }
+    const fallbackLabelmapId = Object.keys(labelmapData.labelmaps ?? {})[0] ??
+        getPrimaryLabelmapId(segmentation.segmentationId);
+    labelmapData.primaryLabelmapId = fallbackLabelmapId;
+    return fallbackLabelmapId;
+}
+function ensureLabelmapState(segmentation) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (!labelmapData) {
+        return;
+    }
+    labelmapData.labelmaps ||= {};
+    const primaryLabelmapId = resolvePrimaryLabelmapId(segmentation, labelmapData);
+    labelmapData.labelmaps[primaryLabelmapId] ||= createPrimaryLabelmapLayer(segmentation, labelmapData, primaryLabelmapId);
+    labelmapData.segmentBindings ||= {};
+    labelmapData.sourceRepresentationName ||= SOURCE_REPRESENTATION_NAME;
+    getSegmentOrder(segmentation).forEach((segmentIndex) => {
+        labelmapData.segmentBindings[segmentIndex] ||= {
+            labelmapId: primaryLabelmapId,
+            labelValue: segmentIndex,
+        };
+    });
+    Object.values(labelmapData.labelmaps).forEach((layer) => {
+        layer.labelToSegmentIndex = {};
+    });
+    Object.entries(labelmapData.segmentBindings).forEach(([segmentIndex, binding]) => {
+        const layer = labelmapData.labelmaps[binding.labelmapId];
+        if (!layer) {
+            return;
+        }
+        layer.labelToSegmentIndex ||= {};
+        layer.labelToSegmentIndex[binding.labelValue] = Number(segmentIndex);
+    });
+    return labelmapData;
+}
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, };

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.d.ts

@@ -0,0 +1,5 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer } from '../../../types/LabelmapTypes';
+declare function createPrivateLabelmap(segmentation: Segmentation, sourceLabelmap: LabelmapLayer): LabelmapLayer;
+declare function moveSegmentToPrivateLabelmap(segmentation: Segmentation, segmentIndex: number): LabelmapLayer | undefined;
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.js

@@ -0,0 +1,106 @@
+import { cache, imageLoader, utilities as csUtils, volumeLoader, } from '@cornerstonejs/core';
+import { getLabelmap, registerLabelmap } from './labelmapLayerStore';
+import { getSegmentBinding, getSegmentsOnLabelmap, setSegmentBinding, } from './labelmapSegmentBindings';
+import { syncLegacyLabelmapData } from './labelmapLegacyAdapter';
+function createPrivateVolumeLabelmap(segmentation, sourceLabelmap) {
+    const sourceVolume = cache.getVolume(sourceLabelmap.volumeId);
+    const volumeId = `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}`;
+    const referencedVolumeId = sourceLabelmap.referencedVolumeId ??
+        sourceVolume?.referencedVolumeId ??
+        sourceLabelmap.volumeId;
+    const volume = volumeLoader.createAndCacheDerivedLabelmapVolume(referencedVolumeId, {
+        volumeId,
+    });
+    return {
+        labelmapId: volumeId,
+        type: 'volume',
+        volumeId,
+        imageIds: volume.imageIds,
+        referencedVolumeId,
+        referencedImageIds: sourceLabelmap.referencedImageIds ?? sourceVolume?.referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateStackLabelmap(segmentation, sourceLabelmap) {
+    const referencedImageIds = sourceLabelmap.referencedImageIds ?? sourceLabelmap.imageIds ?? [];
+    const sourceImageIds = sourceLabelmap.imageIds ?? [];
+    const sourceImage = sourceImageIds[0]
+        ? cache.getImage(sourceImageIds[0])
+        : null;
+    const targetType = sourceImage?.voxelManager?.getConstructor?.().name ?? 'Uint8Array';
+    const images = imageLoader.createAndCacheDerivedImages(referencedImageIds, {
+        getDerivedImageId: (referencedImageId) => `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}-${referencedImageId.slice(-12)}`,
+        targetBuffer: {
+            type: targetType,
+        },
+    });
+    return {
+        labelmapId: `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}`,
+        type: 'stack',
+        imageIds: images.map((image) => image.imageId),
+        referencedVolumeId: sourceLabelmap.referencedVolumeId,
+        referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateLabelmap(segmentation, sourceLabelmap) {
+    if (sourceLabelmap.imageIds?.length ||
+        sourceLabelmap.referencedImageIds?.length) {
+        return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+    }
+    if (sourceLabelmap.volumeId) {
+        return createPrivateVolumeLabelmap(segmentation, sourceLabelmap);
+    }
+    return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+}
+function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
+    const binding = getSegmentBinding(segmentation, segmentIndex);
+    if (!binding) {
+        return;
+    }
+    const sourceLabelmap = getLabelmap(segmentation, binding.labelmapId);
+    if (!sourceLabelmap) {
+        return;
+    }
+    if (getSegmentsOnLabelmap(segmentation, sourceLabelmap.labelmapId).length <= 1) {
+        return sourceLabelmap;
+    }
+    const privateLabelmap = createPrivateLabelmap(segmentation, sourceLabelmap);
+    registerLabelmap(segmentation, privateLabelmap);
+    if (sourceLabelmap.volumeId && privateLabelmap.volumeId) {
+        const sourceVolume = cache.getVolume(sourceLabelmap.volumeId);
+        const targetVolume = cache.getVolume(privateLabelmap.volumeId);
+        sourceVolume.voxelManager.forEach(({ value, index }) => {
+            if (value !== binding.labelValue) {
+                return;
+            }
+            targetVolume.voxelManager.setAtIndex(index, 1);
+            sourceVolume.voxelManager.setAtIndex(index, 0);
+        });
+    }
+    else {
+        const sourceImageIds = sourceLabelmap.imageIds ?? [];
+        const targetImageIds = privateLabelmap.imageIds ?? [];
+        sourceImageIds.forEach((imageId, imageIndex) => {
+            const sourceImage = cache.getImage(imageId);
+            const targetImage = cache.getImage(targetImageIds[imageIndex]);
+            if (!sourceImage || !targetImage) {
+                return;
+            }
+            sourceImage.voxelManager.forEach(({ value, index }) => {
+                if (value !== binding.labelValue) {
+                    return;
+                }
+                targetImage.voxelManager.setAtIndex(index, 1);
+                sourceImage.voxelManager.setAtIndex(index, 0);
+            });
+        });
+    }
+    setSegmentBinding(segmentation, segmentIndex, {
+        labelmapId: privateLabelmap.labelmapId,
+        labelValue: 1,
+    });
+    syncLegacyLabelmapData(segmentation);
+    return privateLabelmap;
+}
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/stateManagement/segmentation/models/SegmentModel.d.ts

@@ -0,0 +1,11 @@
+import type { Segment, Segmentation } from '../../../types/SegmentationStateTypes';
+import type { SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+export default class SegmentModel {
+    private readonly segmentation;
+    private readonly state;
+    constructor(segmentation: Segmentation, state: Segment);
+    get segmentIndex(): number;
+    get label(): string;
+    get binding(): SegmentLabelmapBindingState | undefined;
+    toState(): Segment;
+}

package/dist/esm/stateManagement/segmentation/models/SegmentModel.js

@@ -0,0 +1,19 @@
+import { getSegmentBinding } from '../helpers/labelmapSegmentationState';
+export default class SegmentModel {
+    constructor(segmentation, state) {
+        this.segmentation = segmentation;
+        this.state = state;
+    }
+    get segmentIndex() {
+        return this.state.segmentIndex;
+    }
+    get label() {
+        return this.state.label;
+    }
+    get binding() {
+        return getSegmentBinding(this.segmentation, this.state.segmentIndex);
+    }
+    toState() {
+        return this.state;
+    }
+}

package/dist/esm/stateManagement/segmentation/models/SegmentationModel.d.ts

@@ -0,0 +1,12 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer } from '../../../types/LabelmapTypes';
+import SegmentModel from './SegmentModel';
+export default class SegmentationModel {
+    private readonly state;
+    constructor(state: Segmentation);
+    get segmentationId(): string;
+    get segments(): SegmentModel[];
+    getLabelmaps(): LabelmapLayer[];
+    getBinding(segmentIndex: number): import("../../../types/LabelmapTypes").SegmentLabelmapBindingState;
+    toState(): Segmentation;
+}

package/dist/esm/stateManagement/segmentation/models/SegmentationModel.js

@@ -0,0 +1,23 @@
+import SegmentModel from './SegmentModel';
+import { ensureLabelmapState, getLabelmaps, getSegmentBinding, } from '../helpers/labelmapSegmentationState';
+export default class SegmentationModel {
+    constructor(state) {
+        this.state = state;
+        ensureLabelmapState(state);
+    }
+    get segmentationId() {
+        return this.state.segmentationId;
+    }
+    get segments() {
+        return Object.values(this.state.segments).map((segment) => new SegmentModel(this.state, segment));
+    }
+    getLabelmaps() {
+        return getLabelmaps(this.state);
+    }
+    getBinding(segmentIndex) {
+        return getSegmentBinding(this.state, segmentIndex);
+    }
+    toState() {
+        return this.state;
+    }
+}

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

@@ -1,11 +1,9 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
-import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-import { surfaceDisplay } from '../../tools/displayTools/Surface';
 import { removeSegmentationListener } from './segmentationEventManager';
+import { getSegmentationRepresentationDisplay } from './SegmentationRepresentationDisplayRegistry';
 function removeSegmentationRepresentation(viewportId, specifier, immediate) {
     return _removeSegmentationRepresentations(viewportId, specifier, immediate);
 }
@@ -56,14 +54,12 @@ function _removeRepresentationObject(viewportId, segmentationId, type, immediate
         type,
     });
     representations.forEach((representation) => {
-        if (representation.type === SegmentationRepresentations.Labelmap) {
-            labelmapDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
+        const display = getSegmentationRepresentationDisplay(representation.type);
+        if (display) {
+            display.removeRepresentation(viewportId, representation.segmentationId, immediate);
         }
-        else if (representation.type === SegmentationRepresentations.Contour) {
-            contourDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
-        }
-        else if (representation.type === SegmentationRepresentations.Surface) {
-            surfaceDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
+        else {
+            console.warn(`No display registered for segmentation representation type ${representation.type}.`);
         }
         removeSegmentationListener(representation.segmentationId, representation.type);
     });

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

@@ -5,6 +5,7 @@ import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { getActiveSegmentIndex } from './getActiveSegmentIndex';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { ensureLabelmapState, getSegmentBinding, getLabelmaps, setSegmentBinding, syncLegacyLabelmapData, } from './helpers/labelmapSegmentationState';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (typeof segmentIndex === 'string') {
@@ -22,6 +23,29 @@ function setActiveSegmentIndex(segmentationId, segmentIndex) {
             cachedStats: {},
             active: false,
         };
+        if (segmentation.representationData?.Labelmap) {
+            ensureLabelmapState(segmentation);
+            const primaryLayer = getLabelmaps(segmentation)[0];
+            if (primaryLayer) {
+                setSegmentBinding(segmentation, segmentIndex, {
+                    labelmapId: primaryLayer.labelmapId,
+                    labelValue: segmentIndex,
+                });
+                syncLegacyLabelmapData(segmentation);
+            }
+        }
+    }
+    if (segmentation.representationData?.Labelmap &&
+        !getSegmentBinding(segmentation, segmentIndex)) {
+        ensureLabelmapState(segmentation);
+        const primaryLayer = getLabelmaps(segmentation)[0];
+        if (primaryLayer) {
+            setSegmentBinding(segmentation, segmentIndex, {
+                labelmapId: primaryLayer.labelmapId,
+                labelValue: segmentIndex,
+            });
+            syncLegacyLabelmapData(segmentation);
+        }
     }
     if (segmentation.segments[segmentIndex].active !== true) {
         segmentation.segments[segmentIndex].active = true;

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

@@ -2,18 +2,11 @@ import { eventTarget } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import debounce from '../../utilities/debounce';
-import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
-import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
-import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
 import { getSegmentation } from './getSegmentation';
-const renderers = {
-    [SegmentationRepresentations.Labelmap]: labelmapDisplay,
-    [SegmentationRepresentations.Contour]: contourDisplay,
-    [SegmentationRepresentations.Surface]: surfaceDisplay,
-};
+import { getSegmentationRepresentationDisplay } from './SegmentationRepresentationDisplayRegistry';
 const segmentationListeners = new Map();
 export function addDefaultSegmentationListener(viewport, segmentationId, representationType) {
-    const updateFunction = renderers[representationType].getUpdateFunction(viewport);
+    const updateFunction = getSegmentationRepresentationDisplay(representationType)?.getUpdateFunction(viewport);
     if (updateFunction) {
         addSegmentationListener(segmentationId, representationType, updateFunction);
     }