@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -0,0 +1,224 @@
+import { BaseVolumeViewport, cache } from '@cornerstonejs/core';
+import { getLabelmap, getOrCreateLabelmapVolume } from './labelmapLayerStore';
+import { getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, } from './labelmapSegmentBindings';
+import { moveSegmentToPrivateLabelmap as defaultMoveSegmentToPrivateLabelmap } from './privateLabelmap';
+function getProtectedSegmentIndicesForLayer(segmentation, labelmapId, segmentIndex, overwriteSegmentIndices = []) {
+    return getSegmentsOnLabelmap(segmentation, labelmapId).filter((candidateSegmentIndex) => candidateSegmentIndex !== segmentIndex &&
+        !overwriteSegmentIndices.includes(candidateSegmentIndex));
+}
+function hasProtectedSegmentOverwrite(segmentation, labelmapId, protectedSegmentIndices, voxelManager, options = {}) {
+    if (!voxelManager || !protectedSegmentIndices.length) {
+        return false;
+    }
+    const protectedSet = new Set(protectedSegmentIndices);
+    let hasConflict = false;
+    voxelManager.forEach(({ value }) => {
+        if (!value || hasConflict) {
+            return;
+        }
+        const candidateSegmentIndex = getSegmentIndexForLabelValue(segmentation, labelmapId, Number(value));
+        if (candidateSegmentIndex && protectedSet.has(candidateSegmentIndex)) {
+            hasConflict = true;
+        }
+    }, {
+        imageData: options.segmentationImageData,
+        isInObject: options.isInObject,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    return hasConflict;
+}
+function collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices = []) {
+    if (!labelmapId || !overwriteSegmentIndices.length) {
+        return [];
+    }
+    return overwriteSegmentIndices
+        .map((overwriteSegmentIndex) => getSegmentBinding(segmentation, overwriteSegmentIndex))
+        .filter((binding) => !!binding && binding.labelmapId !== labelmapId);
+}
+function beginLabelmapEditTransaction(segmentation, options) {
+    const { segmentIndex } = options;
+    const overwriteSegmentIndices = options.overwriteSegmentIndices ?? [];
+    if (!segmentIndex) {
+        return {
+            segmentIndex,
+            labelValue: 0,
+            overwriteSegmentIndices,
+            protectedSegmentIndices: [],
+            crossLayerEraseBindings: [],
+            movedSegment: false,
+        };
+    }
+    const binding = getSegmentBinding(segmentation, segmentIndex);
+    const sourceLayer = binding
+        ? getLabelmap(segmentation, binding.labelmapId)
+        : undefined;
+    if (!binding || !sourceLayer) {
+        return {
+            segmentIndex,
+            labelValue: segmentIndex,
+            overwriteSegmentIndices,
+            protectedSegmentIndices: [],
+            crossLayerEraseBindings: [],
+            movedSegment: false,
+        };
+    }
+    let activeLayer = sourceLayer;
+    let labelmapId = binding.labelmapId;
+    let labelValue = binding.labelValue;
+    let movedSegment = false;
+    const protectedSegmentIndices = getProtectedSegmentIndicesForLayer(segmentation, labelmapId, segmentIndex, overwriteSegmentIndices);
+    const shouldMoveSegment = hasProtectedSegmentOverwrite(segmentation, labelmapId, protectedSegmentIndices, options.segmentationVoxelManager, {
+        segmentationImageData: options.segmentationImageData,
+        isInObject: options.isInObject,
+        isInObjectBoundsIJK: options.isInObjectBoundsIJK,
+    });
+    if (shouldMoveSegment) {
+        const moveSegmentToPrivateLabelmap = options.moveSegmentToPrivateLabelmap ??
+            defaultMoveSegmentToPrivateLabelmap;
+        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex);
+        const privateBinding = getSegmentBinding(segmentation, segmentIndex);
+        if (privateLayer && privateBinding) {
+            activeLayer = privateLayer;
+            labelmapId = privateBinding.labelmapId;
+            labelValue = privateBinding.labelValue;
+            movedSegment = privateLayer.labelmapId !== sourceLayer.labelmapId;
+        }
+        else if (privateLayer) {
+            activeLayer = privateLayer;
+            labelmapId = privateLayer.labelmapId;
+            labelValue = 1;
+            movedSegment = privateLayer.labelmapId !== sourceLayer.labelmapId;
+        }
+    }
+    return {
+        segmentIndex,
+        labelmapId,
+        labelValue,
+        sourceLayer,
+        activeLayer,
+        overwriteSegmentIndices,
+        protectedSegmentIndices,
+        crossLayerEraseBindings: collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices),
+        movedSegment,
+    };
+}
+function getViewportImageIds(viewport) {
+    const stackViewport = viewport;
+    return typeof stackViewport?.getImageIds === 'function'
+        ? stackViewport.getImageIds()
+        : [];
+}
+function getCurrentViewportImageId(viewport) {
+    const stackViewport = viewport;
+    return typeof stackViewport?.getCurrentImageId === 'function'
+        ? stackViewport.getCurrentImageId()
+        : undefined;
+}
+function getLayerImageIndex(layer, options) {
+    const currentImageId = options.imageId ?? getCurrentViewportImageId(options.viewport);
+    if (!currentImageId) {
+        return -1;
+    }
+    const sourceImageIndex = options.sourceLayer?.imageIds?.indexOf(currentImageId) ?? -1;
+    if (sourceImageIndex >= 0) {
+        return sourceImageIndex;
+    }
+    const layerImageIndex = layer.imageIds?.indexOf(currentImageId) ?? -1;
+    if (layerImageIndex >= 0) {
+        return layerImageIndex;
+    }
+    return getViewportImageIds(options.viewport).indexOf(currentImageId);
+}
+function getLabelmapLayerImageId(layer, options = {}) {
+    const targetIndex = getLayerImageIndex(layer, options);
+    return targetIndex >= 0 ? layer.imageIds?.[targetIndex] : layer.imageIds?.[0];
+}
+function resolveLabelmapLayerEditTarget(layer, options = {}) {
+    const imageId = getLabelmapLayerImageId(layer, options);
+    if (options.preferVolume ||
+        layer.volumeId ||
+        options.viewport instanceof BaseVolumeViewport) {
+        const volume = getOrCreateLabelmapVolume(layer);
+        return {
+            imageId,
+            imageData: volume?.imageData,
+            voxelManager: volume?.voxelManager,
+            volume,
+        };
+    }
+    const image = imageId ? cache.getImage(imageId) : undefined;
+    return {
+        imageId,
+        voxelManager: image?.voxelManager,
+        image,
+    };
+}
+function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
+    const volume = getOrCreateLabelmapVolume(layer);
+    if (!volume) {
+        return;
+    }
+    volume.voxelManager.forEach(({ value, index, pointIJK }) => {
+        if (value !== binding.labelValue) {
+            return;
+        }
+        const worldPoint = volume.imageData.indexToWorld(pointIJK);
+        if (!options.isInObject(worldPoint)) {
+            return;
+        }
+        volume.voxelManager.setAtIndex(index, 0);
+    }, {
+        imageData: volume.imageData,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    volume.voxelManager
+        ?.getArrayOfModifiedSlices?.()
+        ?.forEach((sliceIndex) => modifiedSlices.add(sliceIndex));
+}
+function eraseStackLayer(layer, binding, options, modifiedSlices) {
+    const stackViewport = options.viewport;
+    const currentImageId = getCurrentViewportImageId(options.viewport) ?? options.imageId;
+    const { image, voxelManager } = resolveLabelmapLayerEditTarget(layer, {
+        viewport: options.viewport,
+        imageId: currentImageId,
+    });
+    if (!image || !voxelManager) {
+        return;
+    }
+    voxelManager.forEach(({ value, index, pointIJK }) => {
+        if (value !== binding.labelValue) {
+            return;
+        }
+        const worldPoint = options.referenceImageData.indexToWorld(pointIJK);
+        if (!options.isInObject(worldPoint)) {
+            return;
+        }
+        voxelManager.setAtIndex(index, 0);
+    }, {
+        imageData: options.referenceImageData,
+        boundsIJK: options.isInObjectBoundsIJK,
+    });
+    const currentSlice = stackViewport.getCurrentImageIdIndex?.();
+    if (typeof currentSlice === 'number') {
+        modifiedSlices.add(currentSlice);
+    }
+}
+function eraseLabelmapEditTransactionOverwrites(segmentation, transaction, options) {
+    if (!transaction?.crossLayerEraseBindings?.length) {
+        return [];
+    }
+    const modifiedSlices = new Set();
+    transaction.crossLayerEraseBindings.forEach((binding) => {
+        const layer = getLabelmap(segmentation, binding.labelmapId);
+        if (!layer) {
+            return;
+        }
+        if (options.viewport instanceof BaseVolumeViewport || layer.volumeId) {
+            eraseVolumeLayer(layer, binding, options, modifiedSlices);
+            return;
+        }
+        eraseStackLayer(layer, binding, options, modifiedSlices);
+    });
+    return Array.from(modifiedSlices);
+}
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, };

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

@@ -0,0 +1,6 @@
+import type { LabelmapLayer } from '../../../types/LabelmapTypes';
+declare function getReferencedImageIdForImageIndex(layer: LabelmapLayer, imageIndex: number): string | undefined;
+declare function forEachLabelmapImageReference(layer: LabelmapLayer, callback: (referencedImageId: string, labelmapImageId: string, imageIndex: number) => void): void;
+declare function getLabelmapImageIdsForReferencedImageId(layer: LabelmapLayer, referencedImageId: string): string[];
+declare function hasMultipleLabelmapImagesPerReferencedImageId(layer: LabelmapLayer): boolean;
+export { forEachLabelmapImageReference, getLabelmapImageIdsForReferencedImageId, getReferencedImageIdForImageIndex, hasMultipleLabelmapImagesPerReferencedImageId, };

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

@@ -0,0 +1,39 @@
+function getReferencedImageIdForImageIndex(layer, imageIndex) {
+    const imageIds = layer.imageIds ?? [];
+    const referencedImageIds = layer.referencedImageIds ?? imageIds;
+    if (!referencedImageIds.length) {
+        return;
+    }
+    if (layer.referencedImageIds?.length &&
+        imageIds.length > referencedImageIds.length &&
+        imageIds.length % referencedImageIds.length === 0) {
+        return referencedImageIds[imageIndex % referencedImageIds.length];
+    }
+    return referencedImageIds[imageIndex];
+}
+function forEachLabelmapImageReference(layer, callback) {
+    layer.imageIds?.forEach((labelmapImageId, imageIndex) => {
+        const referencedImageId = getReferencedImageIdForImageIndex(layer, imageIndex);
+        if (!referencedImageId || !labelmapImageId) {
+            return;
+        }
+        callback(referencedImageId, labelmapImageId, imageIndex);
+    });
+}
+function getLabelmapImageIdsForReferencedImageId(layer, referencedImageId) {
+    const imageIds = [];
+    forEachLabelmapImageReference(layer, (candidateReference, imageId) => {
+        if (candidateReference === referencedImageId) {
+            imageIds.push(imageId);
+        }
+    });
+    return imageIds;
+}
+function hasMultipleLabelmapImagesPerReferencedImageId(layer) {
+    const imageIdsByReference = new Map();
+    forEachLabelmapImageReference(layer, (referencedImageId) => {
+        imageIdsByReference.set(referencedImageId, (imageIdsByReference.get(referencedImageId) ?? 0) + 1);
+    });
+    return Array.from(imageIdsByReference.values()).some((count) => count > 1);
+}
+export { forEachLabelmapImageReference, getLabelmapImageIdsForReferencedImageId, getReferencedImageIdForImageIndex, hasMultipleLabelmapImagesPerReferencedImageId, };

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