@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

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

@@ -1,10 +1,12 @@
-import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, volumeLoader, } from '@cornerstonejs/core';
+import { utilities as csUtils, getEnabledElementByViewportId, volumeLoader, } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import getViewportLabelmapRenderMode from './helpers/getViewportLabelmapRenderMode';
 import { triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, } from './triggerSegmentationEvents';
 import { segmentationStyle } from './SegmentationStyle';
 import { triggerSegmentationAdded } from './events/triggerSegmentationAdded';
+import { ensureLabelmapState, LabelmapImageReferenceResolver, syncLegacyLabelmapData, } from './labelmapModel';
 const initialDefaultState = {
     colorLUT: [],
     segmentations: [],
@@ -12,11 +14,10 @@ const initialDefaultState = {
 };
 export default class SegmentationStateManager {
     constructor(uid) {
-        this._stackLabelmapImageIdReferenceMap = new Map();
-        this._labelmapImageIdReferenceMap = new Map();
         uid ||= csUtils.uuidv4();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
         this.uid = uid;
+        this.labelmapImageReferenceResolver = new LabelmapImageReferenceResolver(this.getSegmentation.bind(this));
     }
     getState() {
         return this.state;
@@ -33,8 +34,7 @@ export default class SegmentationStateManager {
         return this.state.colorLUT.length;
     }
     resetState() {
-        this._stackLabelmapImageIdReferenceMap.clear();
-        this._labelmapImageIdReferenceMap.clear();
+        this.labelmapImageReferenceResolver.reset();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
     }
     getSegmentation(segmentationId) {
@@ -48,6 +48,10 @@ export default class SegmentationStateManager {
                 return;
             }
             Object.assign(segmentation, payload);
+            if (segmentation.representationData?.Labelmap) {
+                ensureLabelmapState(segmentation);
+                syncLegacyLabelmapData(segmentation);
+            }
         });
         triggerSegmentationModified(segmentationId);
     }
@@ -57,9 +61,12 @@ export default class SegmentationStateManager {
         }
         this.updateState((state) => {
             const newSegmentation = csUtils.deepClone(segmentation);
-            if (newSegmentation.representationData.Labelmap &&
-                'volumeId' in newSegmentation.representationData.Labelmap &&
-                !('imageIds' in newSegmentation.representationData.Labelmap)) {
+            if (newSegmentation.representationData?.Labelmap) {
+                ensureLabelmapState(newSegmentation);
+                syncLegacyLabelmapData(newSegmentation);
+            }
+            const labelmapData = newSegmentation.representationData.Labelmap;
+            if (labelmapData?.volumeId && !('imageIds' in labelmapData)) {
                 const imageIds = this.getLabelmapImageIds(newSegmentation.representationData);
                 newSegmentation.representationData
                     .Labelmap.imageIds = imageIds;
@@ -69,6 +76,7 @@ export default class SegmentationStateManager {
         triggerSegmentationAdded(segmentation.segmentationId);
     }
     removeSegmentation(segmentationId) {
+        this.labelmapImageReferenceResolver.removeSegmentation(segmentationId);
         this.updateState((state) => {
             const filteredSegmentations = state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
             state.segmentations.splice(0, state.segmentations.length, ...filteredSegmentations);
@@ -86,6 +94,7 @@ export default class SegmentationStateManager {
         });
         if (existingRepresentations.length > 0) {
             console.debug('A segmentation representation of type', type, 'already exists in viewport', viewportId, 'for segmentation', segmentationId);
+            triggerSegmentationRepresentationModified(viewportId, segmentationId, type);
             return;
         }
         this.updateState((state) => {
@@ -152,148 +161,30 @@ export default class SegmentationStateManager {
         if (!segmentation) {
             return;
         }
-        const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
+        const volumeViewport = getViewportLabelmapRenderMode(enabledElement.viewport) === 'volume';
         const { representationData } = segmentation;
-        const isBaseVolumeSegmentation = 'volumeId' in representationData.Labelmap;
-        const viewport = enabledElement.viewport;
+        const isBaseVolumeSegmentation = !!representationData.Labelmap.volumeId;
         if (!volumeViewport && !isBaseVolumeSegmentation) {
             !this.updateLabelmapSegmentationImageReferences(viewportId, segmentation.segmentationId);
         }
     }
-    _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,
-                });
-            }
-        }
-        if (updateCallback) {
-            updateCallback(viewport, segmentationId, labelmapImageIds);
-        }
-        return viewableLabelmapImageIdFound
-            ? this._stackLabelmapImageIdReferenceMap
-                .get(segmentationId)
-                .get(referenceImageId)
-            : undefined;
-    }
     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);
-        const stackViewport = enabledElement.viewport;
-        return this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, null);
-    }
-    _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);
-        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,
-                        });
-                    }
-                }
-            });
-        });
+        return this.labelmapImageReferenceResolver.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
     }
     getLabelmapImageIds(representationData) {
-        const labelmapData = representationData.Labelmap;
-        let labelmapImageIds;
-        if (labelmapData.imageIds) {
-            labelmapImageIds = labelmapData
-                .imageIds;
-        }
-        else if (!labelmapImageIds &&
-            labelmapData.volumeId) {
-            const volumeId = labelmapData
-                .volumeId;
-            const volume = cache.getVolume(volumeId);
-            labelmapImageIds = volume.imageIds;
-        }
-        return labelmapImageIds;
+        return this.labelmapImageReferenceResolver.getLabelmapImageIds(representationData);
     }
     getLabelmapImageIdsForImageId(imageId, segmentationId) {
-        const key = this._generateMapKey({
-            segmentationId,
-            referenceImageId: imageId,
-        });
-        return this._labelmapImageIdReferenceMap.get(key);
+        return this.labelmapImageReferenceResolver.getLabelmapImageIdsForImageId(imageId, segmentationId);
     }
     getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const stackViewport = enabledElement.viewport;
-        const referenceImageId = stackViewport.getCurrentImageId();
-        return this.getLabelmapImageIdsForImageId(referenceImageId, segmentationId);
+        return this.labelmapImageReferenceResolver.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
     }
     getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
-            return;
-        }
-        const stackViewport = enabledElement.viewport;
-        const currentImageId = stackViewport.getCurrentImageId();
-        const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
-        return imageIdReferenceMap.get(currentImageId);
+        return this.labelmapImageReferenceResolver.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
     }
     getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
-        const segmentation = this.getSegmentation(segmentationId);
-        if (!segmentation) {
-            return [];
-        }
-        this._updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
-        const { viewport } = getEnabledElementByViewportId(viewportId);
-        const imageIds = viewport.getImageIds();
-        const associatedReferenceImageAndLabelmapImageIds = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
-        return imageIds.map((imageId) => {
-            return associatedReferenceImageAndLabelmapImageIds.get(imageId);
-        });
+        return this.labelmapImageReferenceResolver.getStackSegmentationImageIdsForViewport(viewportId, segmentationId);
     }
     removeSegmentationRepresentationsInternal(viewportId, specifier) {
         const removedRepresentations = [];
@@ -359,16 +250,6 @@ export default class SegmentationStateManager {
         }
         return removedRepresentations;
     }
-    _updateLabelmapImageIdReferenceMap({ segmentationId, referenceImageId, labelmapImageId, }) {
-        const key = this._generateMapKey({ segmentationId, referenceImageId });
-        if (!this._labelmapImageIdReferenceMap.has(key)) {
-            this._labelmapImageIdReferenceMap.set(key, [labelmapImageId]);
-            return;
-        }
-        const currentValues = this._labelmapImageIdReferenceMap.get(key);
-        const newValues = Array.from(new Set([...currentValues, labelmapImageId]));
-        this._labelmapImageIdReferenceMap.set(key, newValues);
-    }
     _setActiveSegmentation(state, viewportId, segmentationId) {
         const viewport = state.viewportSegRepresentations[viewportId];
         if (!viewport) {
@@ -427,13 +308,14 @@ export default class SegmentationStateManager {
     }
     setSegmentationRepresentationVisibility(viewportId, specifier, visible) {
         this.updateState((state) => {
-            const viewportRepresentations = this.getSegmentationRepresentations(viewportId, specifier);
+            const viewportRepresentations = state.viewportSegRepresentations[viewportId]?.filter((representation) => representation.segmentationId === specifier.segmentationId &&
+                representation.type === specifier.type);
             if (!viewportRepresentations) {
                 return;
             }
             viewportRepresentations.forEach((representation) => {
                 representation.visible = visible;
-                Object.entries(representation.segments).forEach(([segmentIndex, segment]) => {
+                Object.values(representation.segments).forEach((segment) => {
                     segment.visible = visible;
                 });
             });
@@ -474,9 +356,6 @@ export default class SegmentationStateManager {
         });
         return result;
     }
-    _generateMapKey({ segmentationId, referenceImageId }) {
-        return `${segmentationId}-${referenceImageId}`;
-    }
 }
 async function internalComputeVolumeLabelmapFromStack({ imageIds, options, }) {
     const segmentationImageIds = imageIds;

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

@@ -2,6 +2,8 @@ import { utilities } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+const PREVIEW_COLOR_INDEX = 255;
+const MINIMUM_COLOR_LUT_ENTRIES = PREVIEW_COLOR_INDEX + 1;
 export function addColorLUT(colorLUT, index) {
     const segmentationStateManager = defaultSegmentationStateManager;
     const indexToUse = index ?? getNextColorLUTIndex();
@@ -16,10 +18,14 @@ export function addColorLUT(colorLUT, index) {
         }
         return color;
     });
-    if (colorLUTToUse.length < 255) {
+    if (colorLUTToUse.length < MINIMUM_COLOR_LUT_ENTRIES) {
         const missingColorLUTs = CORNERSTONE_COLOR_LUT.slice(colorLUTToUse.length);
         colorLUTToUse = [...colorLUTToUse, ...missingColorLUTs];
     }
+    while (colorLUTToUse.length < MINIMUM_COLOR_LUT_ENTRIES) {
+        const paletteIndex = ((colorLUTToUse.length - 1) % (CORNERSTONE_COLOR_LUT.length - 1)) + 1;
+        colorLUTToUse.push([...CORNERSTONE_COLOR_LUT[paletteIndex]]);
+    }
     segmentationStateManager.addColorLUT(colorLUTToUse, indexToUse);
     return indexToUse;
 }

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

@@ -1,10 +1,25 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getSegmentation } from './getSegmentation';
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getLabelmapForSegment } from './helpers/labelmapSegmentationState';
 export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
     const imageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
     if (!imageIds?.length) {
         return;
     }
-    return imageIds[0];
+    if (imageIds.length === 1) {
+        return imageIds[0];
+    }
+    const segmentation = getSegmentation(segmentationId);
+    const activeSegmentIndex = getActiveSegmentIndex(segmentationId);
+    const activeLayer = activeSegmentIndex
+        ? getLabelmapForSegment(segmentation, activeSegmentIndex)
+        : undefined;
+    if (!activeLayer?.imageIds?.length) {
+        return imageIds[0];
+    }
+    return (imageIds.find((imageId) => activeLayer.imageIds.includes(imageId)) ??
+        imageIds[0]);
 }
 export function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
     const segmentationStateManager = defaultSegmentationStateManager;

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

@@ -2,16 +2,17 @@ import { cache, utilities } from '@cornerstonejs/core';
 import { getSegmentation } from '../getSegmentation';
 import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
 import { createLabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
+import { getSegmentBinding, getLabelmapForSegment, removeSegmentBinding, } from './labelmapSegmentationState';
 const { DefaultHistoryMemo } = utilities.HistoryMemo;
 export function clearSegmentValue(segmentationId, segmentIndex, options) {
     const segmentation = getSegmentation(segmentationId);
     if (segmentation.representationData.Labelmap) {
-        const { representationData } = segmentation;
-        const labelmapData = representationData.Labelmap;
-        if ('imageIds' in labelmapData || 'volumeId' in labelmapData) {
-            const items = 'imageIds' in labelmapData
-                ? labelmapData.imageIds.map((imageId) => cache.getImage(imageId))
-                : [cache.getVolume(labelmapData.volumeId)];
+        const binding = getSegmentBinding(segmentation, segmentIndex);
+        const layer = getLabelmapForSegment(segmentation, segmentIndex);
+        if (binding && layer) {
+            const items = layer.volumeId
+                ? [cache.getVolume(layer.volumeId)]
+                : (layer.imageIds ?? []).map((imageId) => cache.getImage(imageId));
             items.forEach((item) => {
                 if (!item) {
                     return;
@@ -22,7 +23,7 @@ export function clearSegmentValue(segmentationId, segmentIndex, options) {
                     : null;
                 const useVoxelManager = memo?.voxelManager ?? voxelManager;
                 voxelManager.forEach(({ value, index }) => {
-                    if (value === segmentIndex) {
+                    if (value === binding.labelValue) {
                         useVoxelManager.setAtIndex(index, 0);
                     }
                 });
@@ -30,6 +31,7 @@ export function clearSegmentValue(segmentationId, segmentIndex, options) {
                     DefaultHistoryMemo.push(memo);
                 }
             });
+            removeSegmentBinding(segmentation, segmentIndex);
         }
         triggerSegmentationDataModified(segmentationId);
     }

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 export declare function getLabelmapActorUID(viewportId: string, segmentationId: string): string | undefined;
 export declare function getLabelmapActorEntries(viewportId: string, segmentationId: string): Types.ActorEntry[];
-export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string): Types.ActorEntry;
+export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string, referencedId?: string): Types.ActorEntry;
 export declare function getSurfaceActorEntry(viewportId: string, segmentationId: string, segmentIndex?: number | string): Types.ActorEntry;
 export declare function getSurfaceRepresentationUID(segmentationId: string, segmentIndex?: number | string): string;

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

@@ -33,8 +33,9 @@ export function getLabelmapActorUID(viewportId, segmentationId) {
 export function getLabelmapActorEntries(viewportId, segmentationId) {
     return getActorEntries(viewportId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
 }
-export function getLabelmapActorEntry(viewportId, segmentationId) {
-    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
+export function getLabelmapActorEntry(viewportId, segmentationId, referencedId) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`) &&
+        (!referencedId || actor.referencedId === referencedId));
 }
 export function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID ===

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

@@ -0,0 +1,5 @@
+import { type Types } from '@cornerstonejs/core';
+export type ViewportLabelmapRenderMode = 'image' | 'volume' | 'unsupported';
+export default function getViewportLabelmapRenderMode(viewport: Types.IViewport, options?: {
+    useSliceRendering?: boolean;
+}): ViewportLabelmapRenderMode;

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

@@ -0,0 +1,58 @@
+import { ActorRenderMode, BaseVolumeViewport, StackViewport, Enums, } from '@cornerstonejs/core';
+import { canRenderVolumeViewportLabelmapAsImage, isSliceRenderingEnabled, } from './labelmapImageMapperSupport';
+export default function getViewportLabelmapRenderMode(viewport, options) {
+    const compatibilityViewport = viewport;
+    const useSliceRendering = isSliceRenderingEnabled(options);
+    if (useSliceRendering && canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return 'image';
+    }
+    if (viewport instanceof BaseVolumeViewport) {
+        return 'volume';
+    }
+    if (viewport instanceof StackViewport) {
+        return 'image';
+    }
+    const defaultActor = typeof compatibilityViewport.getDefaultActor === 'function'
+        ? compatibilityViewport.getDefaultActor()
+        : undefined;
+    const actorMapper = defaultActor?.actorMapper;
+    const renderMode = actorMapper?.renderMode;
+    if (renderMode === ActorRenderMode.VTK_VOLUME ||
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE) {
+        return 'volume';
+    }
+    if (renderMode === ActorRenderMode.CPU_VOLUME) {
+        return 'volume';
+    }
+    if (renderMode === ActorRenderMode.VTK_IMAGE ||
+        renderMode === ActorRenderMode.CPU_IMAGE) {
+        return 'image';
+    }
+    const actorClassName = typeof defaultActor?.actor?.getClassName === 'function'
+        ? defaultActor.actor.getClassName()
+        : undefined;
+    if (actorClassName === 'vtkVolume') {
+        return 'volume';
+    }
+    if (actorClassName === 'vtkImageSlice') {
+        return 'image';
+    }
+    if (actorClassName === 'CanvasActor') {
+        const defaultActorRenderMode = actorMapper?.renderMode;
+        if (defaultActorRenderMode === ActorRenderMode.CPU_VOLUME) {
+            return 'volume';
+        }
+        return 'image';
+    }
+    if (compatibilityViewport.type === Enums.ViewportType.PLANAR_NEXT) {
+        if (compatibilityViewport.getVolumeId?.()) {
+            return 'volume';
+        }
+        return typeof compatibilityViewport.getCurrentImageId === 'function'
+            ? 'image'
+            : 'unsupported';
+    }
+    return typeof compatibilityViewport.getCurrentImageId === 'function'
+        ? 'image'
+        : 'unsupported';
+}

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

@@ -0,0 +1,52 @@
+import { Enums, type Types } from '@cornerstonejs/core';
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+declare const DIRECTION_ALIGNMENT_TOLERANCE = 0.999;
+export declare const LABELMAP_IMAGE_MAPPER_URL_PARAM = "labelmapImageMapper";
+export type VolumeViewportLabelmapImageMapperState = {
+    key: string;
+    sliceIndex: number;
+    supported: boolean;
+};
+type ViewportLabelmapImageMapperCompatibilityViewport = Types.IViewport & {
+    getCamera?: () => Pick<Types.ICamera, 'viewPlaneNormal' | 'viewUp'>;
+    getCurrentImageIdIndex?: () => number;
+    getDisplaySetRenderMode?: (displaySetId: string) => Types.ActorRenderMode | string | undefined;
+    getDisplaySetRole?: (displaySetId: string) => 'source' | 'overlay' | undefined;
+    getDisplaySetPresentation?: (dataId: string) => {
+        blendMode?: Enums.BlendModes;
+        slabThickness?: number;
+    };
+    getDefaultActor?: () => (Types.ActorEntry & {
+        actorMapper?: {
+            actor?: {
+                getMapper?: () => {
+                    getBlendMode?: () => Enums.BlendModes;
+                    getSlabThickness?: () => number;
+                };
+            };
+            mapper?: {
+                getBlendMode?: () => Enums.BlendModes;
+                getSlabThickness?: () => number;
+            };
+            renderMode?: Types.ActorRenderMode;
+        };
+    }) | undefined;
+    getSliceViewInfo?: () => {
+        sliceIndex: number;
+    };
+    getSourceDataId?: () => string | undefined;
+    getVolumeId?: () => string | undefined;
+    getResolvedView?: () => {
+        toICamera?: () => Pick<Types.ICamera, 'viewPlaneNormal' | 'viewUp'>;
+    } | undefined;
+    type?: string;
+};
+export declare function isSliceRenderingEnabled(options?: {
+    useSliceRendering?: boolean;
+}): boolean;
+export declare function shouldUseSliceRendering(segmentation?: Segmentation, options?: {
+    useSliceRendering?: boolean;
+}): boolean;
+export declare function canRenderVolumeViewportLabelmapAsImage(viewport: Types.IViewport): viewport is ViewportLabelmapImageMapperCompatibilityViewport;
+export declare function getVolumeViewportLabelmapImageMapperState(viewport: Types.IViewport): VolumeViewportLabelmapImageMapperState;
+export { DIRECTION_ALIGNMENT_TOLERANCE };