@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

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

@@ -0,0 +1,23 @@
+import type { RepresentationsData, Segmentation } from '../../../types/SegmentationStateTypes';
+type GetSegmentation = (segmentationId: string) => Segmentation | undefined;
+declare class LabelmapImageReferenceResolver {
+    private readonly getSegmentation;
+    private readonly stackLabelmapImageIdReferenceMap;
+    private readonly labelmapImageIdReferenceMap;
+    private readonly keysBySegmentationId;
+    constructor(getSegmentation: GetSegmentation);
+    reset(): void;
+    removeSegmentation(segmentationId: string): void;
+    private setLabelmapImageIds;
+    getLabelmapImageIds(representationData: RepresentationsData): any;
+    getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];
+    updateLabelmapSegmentationImageReferences(viewportId: string, segmentationId: string): string | undefined;
+    getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[] | undefined;
+    getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
+    private updateLabelmapSegmentationReferences;
+    private updateAllLabelmapSegmentationImageReferences;
+    private updateLabelmapImageIdReferenceMap;
+    private generateMapKey;
+}
+export default LabelmapImageReferenceResolver;

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

@@ -0,0 +1,269 @@
+import { cache, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import getViewportLabelmapRenderMode from '../helpers/getViewportLabelmapRenderMode';
+import { ensureLabelmapState } from './normalizeLabelmapSegmentationData';
+import { getLabelmaps } from './labelmapLayerStore';
+import { getLabelmapForSegment } from './labelmapSegmentBindings';
+import { getReferencedImageIdToCurrentImageIdMap } from './labelmapLegacyAdapter';
+import { getLabelmapImageIdsForReferencedImageId } from './labelmapImageIdMapping';
+class LabelmapImageReferenceResolver {
+    constructor(getSegmentation) {
+        this.stackLabelmapImageIdReferenceMap = new Map();
+        this.labelmapImageIdReferenceMap = new Map();
+        this.keysBySegmentationId = new Map();
+        this.getSegmentation = getSegmentation;
+    }
+    reset() {
+        this.stackLabelmapImageIdReferenceMap.clear();
+        this.labelmapImageIdReferenceMap.clear();
+        this.keysBySegmentationId.clear();
+    }
+    removeSegmentation(segmentationId) {
+        this.stackLabelmapImageIdReferenceMap.delete(segmentationId);
+        const keys = this.keysBySegmentationId.get(segmentationId);
+        if (keys) {
+            for (const key of keys) {
+                this.labelmapImageIdReferenceMap.delete(key);
+            }
+            this.keysBySegmentationId.delete(segmentationId);
+        }
+    }
+    setLabelmapImageIds(segmentationId, key, labelmapImageIds) {
+        this.labelmapImageIdReferenceMap.set(key, labelmapImageIds);
+        let keys = this.keysBySegmentationId.get(segmentationId);
+        if (!keys) {
+            keys = new Set();
+            this.keysBySegmentationId.set(segmentationId, keys);
+        }
+        keys.add(key);
+    }
+    getLabelmapImageIds(representationData) {
+        const labelmapData = representationData.Labelmap;
+        let labelmapImageIds;
+        if (!labelmapData) {
+            return;
+        }
+        if (labelmapData?.labelmaps) {
+            const imageIds = Object.values(labelmapData.labelmaps).flatMap((layer) => {
+                if (layer.imageIds?.length) {
+                    return layer.imageIds;
+                }
+                if (layer.volumeId) {
+                    return cache.getVolume(layer.volumeId)
+                        ?.imageIds;
+                }
+                return [];
+            });
+            return Array.from(new Set(imageIds.filter(Boolean)));
+        }
+        if (labelmapData.imageIds) {
+            labelmapImageIds = labelmapData
+                .imageIds;
+        }
+        else if (labelmapData.volumeId) {
+            const volumeId = labelmapData
+                .volumeId;
+            const volume = cache.getVolume(volumeId);
+            labelmapImageIds = volume.imageIds;
+        }
+        return labelmapImageIds;
+    }
+    getLabelmapImageIdsForImageId(imageId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation?.representationData?.Labelmap) {
+            return;
+        }
+        ensureLabelmapState(segmentation);
+        return getReferencedImageIdToCurrentImageIdMap(segmentation).get(imageId);
+    }
+    updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        if (!representationData.Labelmap) {
+            return;
+        }
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement || !labelmapImageIds?.length) {
+            return;
+        }
+        return this.updateLabelmapSegmentationReferences(segmentationId, enabledElement.viewport, labelmapImageIds);
+    }
+    getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const viewportRenderMode = getViewportLabelmapRenderMode(viewport);
+        if (viewportRenderMode !== 'image' ||
+            typeof viewport.getCurrentImageId !== 'function') {
+            return;
+        }
+        const referenceImageId = viewport.getCurrentImageId();
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        ensureLabelmapState(segmentation);
+        const viewportImageIds = viewport.getImageIds();
+        const currentIndex = viewportImageIds.indexOf(referenceImageId);
+        const labelmapImageIds = [];
+        getLabelmaps(segmentation).forEach((layer) => {
+            const referencedLabelmapImageIds = getLabelmapImageIdsForReferencedImageId(layer, referenceImageId);
+            if (referencedLabelmapImageIds.length) {
+                labelmapImageIds.push(...referencedLabelmapImageIds);
+                return;
+            }
+            if (currentIndex !== -1 && layer.imageIds?.[currentIndex]) {
+                labelmapImageIds.push(layer.imageIds[currentIndex]);
+                return;
+            }
+            layer.imageIds?.some((candidateImageId) => {
+                const viewableImageId = viewport.isReferenceViewable({ referencedImageId: candidateImageId }, { asOverlay: true });
+                if (viewableImageId) {
+                    labelmapImageIds.push(candidateImageId);
+                }
+                return !!viewableImageId;
+            });
+        });
+        const resolvedImageIds = Array.from(new Set(labelmapImageIds));
+        const key = this.generateMapKey({
+            segmentationId,
+            referenceImageId,
+        });
+        this.setLabelmapImageIds(segmentationId, key, resolvedImageIds);
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const activeSegmentIndex = Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active);
+        const activeImageId = activeSegmentIndex
+            ? getLabelmapForSegment(segmentation, Number(activeSegmentIndex))
+                ?.imageIds?.[currentIndex]
+            : undefined;
+        this.stackLabelmapImageIdReferenceMap
+            .get(segmentationId)
+            .set(referenceImageId, activeImageId ?? resolvedImageIds[0]);
+        return resolvedImageIds;
+    }
+    getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const viewportRenderMode = getViewportLabelmapRenderMode(viewport);
+        if (viewportRenderMode !== 'image' ||
+            typeof viewport.getCurrentImageId !== 'function') {
+            return;
+        }
+        const currentImageId = viewport.getCurrentImageId();
+        const currentImageIds = this.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+        if (!currentImageIds?.length) {
+            return;
+        }
+        const segmentation = this.getSegmentation(segmentationId);
+        const currentIndex = viewport
+            .getImageIds()
+            .indexOf(currentImageId);
+        const activeSegmentIndex = segmentation
+            ? Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active)
+            : undefined;
+        const activeImageId = segmentation && activeSegmentIndex
+            ? getLabelmapForSegment(segmentation, Number(activeSegmentIndex))
+                ?.imageIds?.[currentIndex]
+            : undefined;
+        return activeImageId ?? currentImageIds[0];
+    }
+    getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return [];
+        }
+        this.updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        const imageIds = enabledElement?.viewport.getImageIds?.() ?? [];
+        const imageIdMap = getReferencedImageIdToCurrentImageIdMap(segmentation);
+        return imageIds.flatMap((imageId) => imageIdMap.get(imageId) ?? []);
+    }
+    updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds, updateCallback) {
+        const referenceImageId = viewport.getCurrentImageId();
+        let viewableLabelmapImageIdFound = false;
+        for (const labelmapImageId of labelmapImageIds) {
+            const viewableImageId = viewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            if (viewableImageId) {
+                viewableLabelmapImageIdFound = true;
+                this.stackLabelmapImageIdReferenceMap
+                    .get(segmentationId)
+                    .set(referenceImageId, labelmapImageId);
+                this.updateLabelmapImageIdReferenceMap({
+                    segmentationId,
+                    referenceImageId,
+                    labelmapImageId,
+                });
+            }
+        }
+        updateCallback?.(viewport, segmentationId, labelmapImageIds);
+        return viewableLabelmapImageIdFound
+            ? this.stackLabelmapImageIdReferenceMap
+                .get(segmentationId)
+                .get(referenceImageId)
+            : undefined;
+    }
+    updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        if (!this.stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this.stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        if (!representationData.Labelmap) {
+            return;
+        }
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement || !labelmapImageIds?.length) {
+            return;
+        }
+        const stackViewport = enabledElement.viewport;
+        this.updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
+            const imageIds = stackViewport.getImageIds();
+            imageIds.forEach((referenceImageId, index) => {
+                for (const labelmapImageId of labelmapImageIds) {
+                    const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId, sliceIndex: index }, { asOverlay: true, withNavigation: true });
+                    if (viewableImageId) {
+                        this.stackLabelmapImageIdReferenceMap
+                            .get(segmentationId)
+                            .set(referenceImageId, labelmapImageId);
+                        this.updateLabelmapImageIdReferenceMap({
+                            segmentationId,
+                            referenceImageId,
+                            labelmapImageId,
+                        });
+                    }
+                }
+            });
+        });
+    }
+    updateLabelmapImageIdReferenceMap({ segmentationId, referenceImageId, labelmapImageId, }) {
+        const key = this.generateMapKey({ segmentationId, referenceImageId });
+        if (!this.labelmapImageIdReferenceMap.has(key)) {
+            this.setLabelmapImageIds(segmentationId, key, [labelmapImageId]);
+            return;
+        }
+        const currentValues = this.labelmapImageIdReferenceMap.get(key) ?? [];
+        const newValues = Array.from(new Set([...currentValues, labelmapImageId]));
+        this.setLabelmapImageIds(segmentationId, key, newValues);
+    }
+    generateMapKey({ segmentationId, referenceImageId }) {
+        return `${segmentationId}-${referenceImageId}`;
+    }
+}
+export default LabelmapImageReferenceResolver;

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

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapSegmentationData, LabelmapLayer } from '../../../types/LabelmapTypes';
+declare function getLabelmap(segmentation: Segmentation, labelmapId: string): LabelmapLayer | undefined;
+declare function getLabelmaps(segmentation: Segmentation): LabelmapLayer[];
+declare function registerLabelmap(segmentation: Segmentation, layer: LabelmapLayer): void;
+declare function removeLabelmap(segmentation: Segmentation, labelmapId: string): void;
+declare function getOrCreateLabelmapVolume(layer: LabelmapLayer): Types.IImageVolume | undefined;
+declare function getLabelmapIds(segmentation: Segmentation): string[];
+declare function getLabelmapDataById(segmentation: Segmentation, labelmapId: string): LabelmapSegmentationData | undefined;
+declare function getScalarArrayLengthFromLabelmap(layer: LabelmapLayer): number;
+declare function getConstructorNameForLabelmap(layer: LabelmapLayer): string;
+declare function getLabelmapForImageId(segmentation: Segmentation, imageId: string): LabelmapLayer | undefined;
+declare function getLabelmapForVolumeId(segmentation: Segmentation, volumeId: string): LabelmapLayer | undefined;
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, };

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