@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,246 @@
+import { ActorRenderMode, Enums, VolumeViewport, } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { getLabelmaps } from '../labelmapModel/labelmapLayerStore';
+const DIRECTION_ALIGNMENT_TOLERANCE = 0.999;
+const MINIMUM_SLAB_THICKNESS = 0.1;
+const SLAB_THICKNESS_EPSILON = 1e-3;
+export const LABELMAP_IMAGE_MAPPER_URL_PARAM = 'labelmapImageMapper';
+function isSupportedImageMapperBlendMode(blendMode) {
+    return (blendMode === Enums.BlendModes.COMPOSITE ||
+        blendMode === Enums.BlendModes.AVERAGE_INTENSITY_BLEND);
+}
+function isPlanarGpuVolumeSliceViewport(viewport) {
+    const compatibilityViewport = viewport;
+    if (compatibilityViewport.type !== Enums.ViewportType.PLANAR_NEXT) {
+        return false;
+    }
+    return (getPlanarPrimaryRenderMode(compatibilityViewport) ===
+        ActorRenderMode.VTK_VOLUME_SLICE);
+}
+function getPlanarPrimaryRenderMode(viewport) {
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    if (primaryDataId) {
+        const renderMode = viewport.getDisplaySetRenderMode?.(primaryDataId);
+        if (renderMode) {
+            return renderMode;
+        }
+    }
+    return viewport.getDefaultActor?.()?.actorMapper?.renderMode;
+}
+function getPlanarVolumeSliceMapper(viewport) {
+    const defaultActor = viewport.getDefaultActor?.();
+    return (defaultActor?.actorMapper?.mapper ??
+        defaultActor?.actorMapper?.actor?.getMapper?.());
+}
+function getPlanarPrimaryDataId(viewport) {
+    const sourceDataId = viewport.getSourceDataId?.();
+    if (sourceDataId) {
+        return sourceDataId;
+    }
+    const renderModes = viewport._debug?.renderModes;
+    if (!renderModes) {
+        return;
+    }
+    return (Object.entries(renderModes).find(([dataId, renderMode]) => viewport.getDisplaySetRole?.(dataId) === 'source' &&
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE)?.[0] ??
+        Object.entries(renderModes).find(([, renderMode]) => renderMode === ActorRenderMode.VTK_VOLUME_SLICE)?.[0]);
+}
+function getLabelmapImageMapperCamera(viewport) {
+    const compatibilityViewport = viewport;
+    const resolvedCamera = compatibilityViewport
+        .getResolvedView?.()
+        ?.toICamera?.();
+    if (isLabelmapImageMapperCamera(resolvedCamera)) {
+        return resolvedCamera;
+    }
+    const legacyCamera = compatibilityViewport.getCamera?.();
+    return isLabelmapImageMapperCamera(legacyCamera) ? legacyCamera : undefined;
+}
+function isLabelmapImageMapperCamera(camera) {
+    const candidate = camera;
+    return Boolean(candidate &&
+        isPoint3Like(candidate.viewPlaneNormal) &&
+        isPoint3Like(candidate.viewUp));
+}
+function isPoint3Like(value) {
+    const candidate = value;
+    return Boolean(candidate &&
+        typeof candidate.length === 'number' &&
+        candidate.length >= 3 &&
+        Number.isFinite(Number(candidate[0])) &&
+        Number.isFinite(Number(candidate[1])) &&
+        Number.isFinite(Number(candidate[2])));
+}
+function getPlanarVolumeDataPresentation(viewport) {
+    if (!viewport.getDisplaySetPresentation) {
+        return;
+    }
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    return primaryDataId
+        ? viewport.getDisplaySetPresentation(primaryDataId)
+        : undefined;
+}
+function getCompatibilityBlendMode(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return viewport.getBlendMode?.();
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return;
+    }
+    const presentationBlendMode = getPlanarVolumeDataPresentation(viewport)?.blendMode;
+    if (presentationBlendMode !== undefined) {
+        return presentationBlendMode;
+    }
+    return Enums.BlendModes.AVERAGE_INTENSITY_BLEND;
+}
+function getCompatibilitySlabThickness(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return viewport.getSlabThickness?.() ?? MINIMUM_SLAB_THICKNESS;
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return MINIMUM_SLAB_THICKNESS;
+    }
+    const mapperSlabThickness = getPlanarVolumeSliceMapper(viewport)?.getSlabThickness?.();
+    if (typeof mapperSlabThickness === 'number') {
+        return mapperSlabThickness;
+    }
+    return (getPlanarVolumeDataPresentation(viewport)?.slabThickness ??
+        MINIMUM_SLAB_THICKNESS);
+}
+export function isSliceRenderingEnabled(options) {
+    if (options?.useSliceRendering) {
+        return true;
+    }
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    if (!params.has(LABELMAP_IMAGE_MAPPER_URL_PARAM)) {
+        return false;
+    }
+    const value = params.get(LABELMAP_IMAGE_MAPPER_URL_PARAM);
+    if (value === null || value === '') {
+        return true;
+    }
+    const normalizedValue = value.trim().toLowerCase();
+    return (normalizedValue !== '0' &&
+        normalizedValue !== 'false' &&
+        normalizedValue !== 'off');
+}
+export function shouldUseSliceRendering(segmentation, options) {
+    if (isSliceRenderingEnabled(options)) {
+        return true;
+    }
+    if (!segmentation?.representationData?.Labelmap) {
+        return false;
+    }
+    const layers = getLabelmaps(segmentation);
+    return layers.length > 1 && layers.some((layer) => layer.type === 'stack');
+}
+export function canRenderVolumeViewportLabelmapAsImage(viewport) {
+    const isLegacyVolumeViewport = viewport instanceof VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return false;
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return false;
+    }
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return false;
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+export function getVolumeViewportLabelmapImageMapperState(viewport) {
+    const compatibilityViewport = viewport;
+    const isLegacyVolumeViewport = viewport instanceof VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return {
+            key: 'unsupported:viewport',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const camera = getLabelmapImageMapperCamera(viewport);
+    if (!camera) {
+        return {
+            key: 'unsupported:camera',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const { viewPlaneNormal, viewUp } = camera;
+    const normalizedNormal = vec3.normalize(vec3.create(), viewPlaneNormal);
+    const normalizedViewUp = vec3.normalize(vec3.create(), viewUp);
+    let sliceIndex;
+    if (isLegacyVolumeViewport) {
+        try {
+            sliceIndex = viewport.getSliceViewInfo().sliceIndex;
+        }
+        catch {
+            sliceIndex = undefined;
+        }
+    }
+    else {
+        sliceIndex = compatibilityViewport.getCurrentImageIdIndex?.();
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    const orientationKey = [
+        normalizedNormal.map((value) => value.toFixed(3)).join(','),
+        normalizedViewUp.map((value) => value.toFixed(3)).join(','),
+    ].join('|');
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return {
+            key: `unsupported:blend:${blendMode}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return {
+            key: `unsupported:slab:${slabThickness.toFixed(3)}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+        }
+        catch {
+            return {
+                key: `unsupported:oblique:${orientationKey}`,
+                sliceIndex: sliceIndex ?? NaN,
+                supported: false,
+            };
+        }
+    }
+    if (isNextPlanarViewport &&
+        getPlanarPrimaryRenderMode(compatibilityViewport) !==
+            ActorRenderMode.VTK_VOLUME_SLICE) {
+        return {
+            key: `unsupported:renderMode:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    return {
+        key: `supported:${orientationKey}:${sliceIndex ?? 0}`,
+        sliceIndex: sliceIndex ?? NaN,
+        supported: true,
+    };
+}
+export { DIRECTION_ALIGNMENT_TOLERANCE };

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

@@ -0,0 +1 @@
+export * from '../labelmapModel';

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

@@ -0,0 +1 @@
+export * from '../labelmapModel';

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

@@ -1,5 +1,6 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { cache } from '@cornerstonejs/core';
+import { ensureLabelmapState, syncLegacyLabelmapData, } from './labelmapSegmentationState';
 function normalizeSegmentationInput(segmentationInput) {
     const { segmentationId, representation, config } = segmentationInput;
     const { type, data: inputData } = representation;
@@ -12,17 +13,27 @@ function normalizeSegmentationInput(segmentationInput) {
     }
     const normalizedSegments = normalizeSegments(config?.segments, type, data);
     delete config?.segments;
-    return {
+    const segmentation = {
         segmentationId,
         label: config?.label ?? null,
+        fallbackLabel: config?.fallbackLabel ?? null,
         cachedStats: config?.cachedStats ?? {},
         segments: normalizedSegments,
+        segmentOrder: config?.segmentOrder ??
+            Object.keys(normalizedSegments)
+                .map(Number)
+                .sort((a, b) => a - b),
         representationData: {
             [type]: {
                 ...data,
             },
         },
     };
+    if (type === SegmentationRepresentations.Labelmap) {
+        ensureLabelmapState(segmentation);
+        syncLegacyLabelmapData(segmentation);
+    }
+    return segmentation;
 }
 function normalizeContourData(contourData) {
     contourData.geometryIds = contourData.geometryIds ?? [];

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

@@ -1,4 +1,4 @@
-import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId, utilities } from '@cornerstonejs/core';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { SegmentationRepresentations } from '../../enums';
@@ -40,7 +40,7 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
 function getColorLUTIndex(config) {
     const { colorLUTOrIndex } = config || {};
     if (colorLUTOrIndex === undefined) {
-        const index = addColorLUT(JSON.parse(JSON.stringify(CORNERSTONE_COLOR_LUT)));
+        const index = addColorLUT(utilities.deepClone(CORNERSTONE_COLOR_LUT));
         return index;
     }
     if (typeof colorLUTOrIndex === 'number') {
@@ -51,7 +51,7 @@ function getColorLUTIndex(config) {
         const index = addColorLUT(colorLUTOrIndex);
         return index;
     }
-    const index = addColorLUT(JSON.parse(JSON.stringify(CORNERSTONE_COLOR_LUT)));
+    const index = addColorLUT(utilities.deepClone(CORNERSTONE_COLOR_LUT));
     return index;
 }
 export { internalAddSegmentationRepresentation };

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

@@ -0,0 +1,9 @@
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, } from './normalizeLabelmapSegmentationData';
+export type { LabelmapSegmentationWithState } from './normalizeLabelmapSegmentationData';
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, } from './labelmapLayerStore';
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData, } from './labelmapLegacyAdapter';
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, } from './labelmapSegmentBindings';
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap, } from './privateLabelmap';
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, } from './labelmapEditTransaction';
+export type { BeginLabelmapEditTransactionOptions, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, } from './labelmapEditTransaction';
+export { default as LabelmapImageReferenceResolver } from './labelmapImageReferenceResolver';

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

@@ -0,0 +1,7 @@
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, } from './normalizeLabelmapSegmentationData';
+export { getConstructorNameForLabelmap, getLabelmap, getLabelmapDataById, getLabelmapForImageId, getLabelmapForVolumeId, getLabelmapIds, getLabelmaps, getOrCreateLabelmapVolume, getScalarArrayLengthFromLabelmap, registerLabelmap, removeLabelmap, } from './labelmapLayerStore';
+export { getReferencedImageIdToCurrentImageIdMap, syncLegacyLabelmapData, } from './labelmapLegacyAdapter';
+export { getLabelmapForSegment, getLabelValueForSegment, getSegmentBinding, getSegmentIndexForLabelValue, getSegmentsOnLabelmap, removeSegmentBinding, resolveLabelmapForSegment, setSegmentBinding, } from './labelmapSegmentBindings';
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap, } from './privateLabelmap';
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, } from './labelmapEditTransaction';
+export { default as LabelmapImageReferenceResolver } from './labelmapImageReferenceResolver';

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

@@ -0,0 +1,54 @@
+import type { Types } from '@cornerstonejs/core';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer, SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+type MoveSegmentToPrivateLabelmap = (segmentation: Segmentation, segmentIndex: number) => LabelmapLayer | undefined;
+type BeginLabelmapEditTransactionOptions = {
+    segmentIndex: number;
+    overwriteSegmentIndices?: number[];
+    segmentationVoxelManager?: Types.IVoxelManager<number>;
+    segmentationImageData?: vtkImageData;
+    isInObject?: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK?: Types.BoundsIJK;
+    moveSegmentToPrivateLabelmap?: MoveSegmentToPrivateLabelmap;
+};
+type LabelmapEditTransaction = {
+    segmentIndex: number;
+    labelmapId?: string;
+    labelValue: number;
+    sourceLayer?: LabelmapLayer;
+    activeLayer?: LabelmapLayer;
+    overwriteSegmentIndices: number[];
+    protectedSegmentIndices: number[];
+    crossLayerEraseBindings: SegmentLabelmapBindingState[];
+    movedSegment: boolean;
+};
+type ResolveLabelmapLayerEditTargetOptions = {
+    viewport?: Types.IViewport;
+    imageId?: string;
+    sourceLayer?: LabelmapLayer;
+    preferVolume?: boolean;
+};
+type LabelmapLayerEditTarget = {
+    imageId?: string;
+    imageData?: vtkImageData;
+    voxelManager?: Types.IVoxelManager<number>;
+    volume?: Types.IImageVolume;
+    image?: Types.IImage;
+};
+type EraseLabelmapEditTransactionOptions = {
+    viewport: Types.IViewport;
+    referenceImageData: vtkImageData;
+    isInObject: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK?: Types.BoundsIJK;
+    imageId?: string;
+};
+declare function getProtectedSegmentIndicesForLayer(segmentation: Segmentation, labelmapId: string, segmentIndex: number, overwriteSegmentIndices?: number[]): number[];
+declare function hasProtectedSegmentOverwrite(segmentation: Segmentation, labelmapId: string, protectedSegmentIndices: number[], voxelManager?: Types.IVoxelManager<number>, options?: Pick<BeginLabelmapEditTransactionOptions, 'segmentationImageData' | 'isInObject' | 'isInObjectBoundsIJK'>): boolean;
+declare function collectCrossLayerEraseBindings(segmentation: Segmentation, labelmapId: string | undefined, overwriteSegmentIndices?: number[]): SegmentLabelmapBindingState[];
+declare function beginLabelmapEditTransaction(segmentation: Segmentation, options: BeginLabelmapEditTransactionOptions): LabelmapEditTransaction;
+declare function getLabelmapLayerImageId(layer: LabelmapLayer, options?: ResolveLabelmapLayerEditTargetOptions): string | undefined;
+declare function resolveLabelmapLayerEditTarget(layer: LabelmapLayer, options?: ResolveLabelmapLayerEditTargetOptions): LabelmapLayerEditTarget;
+declare function eraseLabelmapEditTransactionOverwrites(segmentation: Segmentation, transaction: LabelmapEditTransaction | undefined, options: EraseLabelmapEditTransactionOptions): number[];
+export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, };
+export type { BeginLabelmapEditTransactionOptions, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, };

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