@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/legacyVolumePlan.js

@@ -0,0 +1,143 @@
+import { addVolumesToViewports, Enums, cache, volumeLoader, utilities, } from '@cornerstonejs/core';
+import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { getLabelmaps, getOrCreateLabelmapVolume, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { addVolumesAsIndependentComponents } from '../addVolumesAsIndependentComponents';
+import { createLabelmapRepresentationUID } from '../labelmapRepresentationUID';
+import { createLabelmapRenderPlan } from './createLabelmapRenderPlan';
+import { addLabelmapToPlanarGenericViewport, isPlanarNextVolumeViewport, } from './planarGenericVolumeLabelmap';
+const { uuidv4 } = utilities;
+function createLegacyVolumeLabelmapPlan({ config, isVolumeImageMapper, renderMode, segmentation, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'legacy-volume',
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+        getExpectedRepresentationUIDs: () => getExpectedVolumeLabelmapRepresentationUIDs(segmentation, segmentationId),
+        mount: ({ labelMapData }) => mountLegacyVolumeLabelmap({
+            config,
+            labelMapData,
+            segmentation,
+            segmentationId,
+            viewport,
+        }),
+    });
+}
+function getExpectedVolumeLabelmapRepresentationUIDs(segmentation, segmentationId) {
+    return getLabelmaps(segmentation)
+        .filter(canResolveLayerAsVolume)
+        .map((layer) => createLabelmapRepresentationUID({
+        segmentationId,
+        referencedId: layer.labelmapId,
+    }));
+}
+async function mountLegacyVolumeLabelmap({ config, labelMapData, segmentation, segmentationId, viewport, }) {
+    const { id: viewportId } = viewport;
+    const visibility = true;
+    const immediateRender = false;
+    const suppressEvents = true;
+    const volumeCompatibleViewport = viewport;
+    const labelmapLayers = getVolumeBackedLabelmapLayers(segmentation);
+    if (!labelmapLayers.length) {
+        const volumeLabelMapData = labelMapData;
+        const volumeId = ensureVolumeHasVolumeId(volumeLabelMapData, segmentation);
+        if (!cache.getVolume(volumeId)) {
+            await handleMissingVolume(labelMapData);
+        }
+        labelmapLayers.push({
+            labelmapId: volumeId,
+            type: 'volume',
+            volumeId,
+            imageIds: cache.getVolume(volumeId)?.imageIds,
+        });
+    }
+    let blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+    let useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
+    if (useIndependentComponents) {
+        const referenceVolumeId = volumeCompatibleViewport.getVolumeId?.();
+        const baseVolume = cache.getVolume(referenceVolumeId);
+        const segVolume = cache.getVolume(labelmapLayers[0]?.volumeId);
+        const segDims = segVolume.dimensions;
+        const refDims = baseVolume.dimensions;
+        if (segDims[0] !== refDims[0] ||
+            segDims[1] !== refDims[1] ||
+            segDims[2] !== refDims[2]) {
+            useIndependentComponents = false;
+            blendMode = Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+            console.debug('Dimensions mismatch - falling back to regular volume addition');
+        }
+    }
+    const volumeInputs = labelmapLayers.map((layer) => ({
+        volumeId: layer.volumeId,
+        visibility,
+        representationUID: createLabelmapRepresentationUID({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        }),
+        useIndependentComponents,
+        blendMode,
+    }));
+    if (isPlanarNextVolumeViewport(viewport)) {
+        return addLabelmapToPlanarGenericViewport({
+            blendMode,
+            labelmapLayers,
+            segmentationId,
+            viewport,
+            visibility,
+        });
+    }
+    if (!volumeInputs[0].useIndependentComponents) {
+        await addVolumesToViewports(viewport.getRenderingEngine(), volumeInputs, [viewportId], immediateRender, suppressEvents);
+        triggerSegmentationDataModified(segmentationId);
+        return;
+    }
+    return addVolumesAsIndependentComponents({
+        viewport: volumeCompatibleViewport,
+        volumeInputs,
+        segmentationId,
+    });
+}
+function canResolveLayerAsVolume(layer) {
+    return Boolean(layer.volumeId || layer.geometryVolumeId || layer.imageIds?.length);
+}
+function getVolumeBackedLabelmapLayers(segmentation) {
+    return getLabelmaps(segmentation)
+        .map((layer) => {
+        if (layer.volumeId) {
+            return layer;
+        }
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume?.volumeId) {
+            return;
+        }
+        return {
+            ...layer,
+            volumeId: volume.volumeId,
+        };
+    })
+        .filter((layer) => Boolean(layer));
+}
+function ensureVolumeHasVolumeId(labelMapData, segmentation) {
+    let { volumeId } = labelMapData;
+    if (!volumeId) {
+        volumeId = uuidv4();
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            volumeId,
+        };
+        labelMapData.volumeId = volumeId;
+        triggerSegmentationModified(segmentation.segmentationId);
+    }
+    return volumeId;
+}
+async function handleMissingVolume(labelMapData) {
+    const stackData = labelMapData;
+    const hasImageIds = stackData.imageIds.length > 0;
+    if (!hasImageIds) {
+        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
+    }
+    const volume = await volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId ?? uuidv4(), stackData.imageIds);
+    return volume;
+}
+export { createLegacyVolumeLabelmapPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/planarGenericVolumeLabelmap.d.ts

@@ -0,0 +1,40 @@
+import { type Types, Enums } from '@cornerstonejs/core';
+import type { LabelmapRenderPlanMountResult } from './types';
+type PlanarNextVolumeViewport = Types.IViewport & {
+    getCurrentImageIdIndex?: () => number;
+    getDefaultActor?: () => (Types.ActorEntry & {
+        actorMapper?: {
+            renderMode?: Types.ActorRenderMode;
+        };
+    }) | undefined;
+    getVolumeId: () => string | undefined;
+    getViewReference: (specifier?: Types.ViewReferenceSpecifier) => Types.ViewReference;
+    getViewState: () => {
+        orientation?: unknown;
+    };
+    getActors?: () => Types.ActorEntry[];
+    render?: () => void;
+    addDisplaySet: (displaySetId: string, options: {
+        orientation?: unknown;
+        role?: 'source' | 'overlay';
+    }) => Promise<void>;
+    setDisplaySetPresentation: (dataId: string, props: {
+        blendMode?: Enums.BlendModes;
+        visible?: boolean;
+    }) => void;
+    setViewReference: (viewReference: Types.ViewReference) => void;
+    type: string;
+};
+declare function isPlanarNextVolumeViewport(viewport: Types.IViewport): viewport is PlanarNextVolumeViewport;
+declare function addLabelmapToPlanarGenericViewport(args: {
+    blendMode: Enums.BlendModes;
+    labelmapLayers: Array<{
+        imageIds?: string[];
+        labelmapId: string;
+        volumeId?: string;
+    }>;
+    segmentationId: string;
+    viewport: PlanarNextVolumeViewport;
+    visibility: boolean;
+}): Promise<LabelmapRenderPlanMountResult>;
+export { addLabelmapToPlanarGenericViewport, isPlanarNextVolumeViewport, type PlanarNextVolumeViewport, };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/planarGenericVolumeLabelmap.js

@@ -0,0 +1,79 @@
+import { ActorRenderMode, Enums, cache, utilities, } from '@cornerstonejs/core';
+import { createLabelmapRepresentationUID } from '../labelmapRepresentationUID';
+function isPlanarNextVolumeViewport(viewport) {
+    const genericViewport = viewport;
+    return (genericViewport.type === Enums.ViewportType.PLANAR_NEXT &&
+        typeof genericViewport.getVolumeId === 'function' &&
+        typeof genericViewport.getViewReference === 'function' &&
+        typeof genericViewport.getViewState === 'function' &&
+        typeof genericViewport.addDisplaySet === 'function' &&
+        typeof genericViewport.setDisplaySetPresentation === 'function' &&
+        typeof genericViewport.setViewReference === 'function');
+}
+async function addLabelmapToPlanarGenericViewport(args) {
+    const { blendMode, labelmapLayers, segmentationId, viewport, visibility } = args;
+    const sourceVolumeRenderMode = getPlanarNextVolumeRenderMode(viewport);
+    if (!sourceVolumeRenderMode) {
+        return;
+    }
+    const sourceVolumeId = viewport.getVolumeId();
+    const sourceViewReference = sourceVolumeId
+        ? viewport.getViewReference({ volumeId: sourceVolumeId })
+        : viewport.getViewReference();
+    const requestedOrientation = viewport.getViewState().orientation;
+    const currentImageIdIndex = Math.max(0, viewport.getCurrentImageIdIndex?.() ?? 0);
+    let firstActorEntry;
+    for (const layer of labelmapLayers) {
+        if (!layer.volumeId) {
+            continue;
+        }
+        const volume = cache.getVolume(layer.volumeId);
+        if (!volume) {
+            throw new Error(`imageVolume with id: ${layer.volumeId} does not exist, you need to create/allocate the volume first`);
+        }
+        const representationUID = createLabelmapRepresentationUID({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        });
+        const dataId = representationUID;
+        utilities.genericViewportDataSetMetadataProvider.add(dataId, {
+            kind: 'planar',
+            imageIds: volume.imageIds,
+            initialImageIdIndex: Math.min(currentImageIdIndex, Math.max(volume.imageIds.length - 1, 0)),
+            reference: {
+                kind: 'segmentation',
+                segmentationId,
+                representationUID,
+                labelmapId: layer.labelmapId,
+            },
+            volumeId: layer.volumeId,
+        });
+        await viewport.addDisplaySet(dataId, {
+            orientation: requestedOrientation,
+            role: 'overlay',
+        });
+        viewport.setDisplaySetPresentation(dataId, {
+            blendMode,
+            visible: visibility,
+        });
+        firstActorEntry ||= viewport
+            .getActors?.()
+            .find((actorEntry) => actorEntry.representationUID === representationUID);
+    }
+    viewport.setViewReference(sourceViewReference);
+    viewport.render?.();
+    if (firstActorEntry) {
+        return {
+            uid: firstActorEntry.uid,
+            actor: firstActorEntry.actor,
+        };
+    }
+}
+function getPlanarNextVolumeRenderMode(viewport) {
+    const renderMode = viewport.getDefaultActor?.()?.actorMapper?.renderMode;
+    if (renderMode === ActorRenderMode.CPU_VOLUME ||
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE) {
+        return renderMode;
+    }
+}
+export { addLabelmapToPlanarGenericViewport, isPlanarNextVolumeViewport, };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/removeLabelmapRepresentationFromViewport.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function removeLabelmapRepresentationFromViewport(viewport: Types.IViewport, segmentationId: string): void;
+export { removeLabelmapRepresentationFromViewport };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/removeLabelmapRepresentationFromViewport.js

@@ -0,0 +1,18 @@
+import { getLabelmapActorEntries } from '../../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import removeLabelmapRepresentationData from '../removeLabelmapRepresentationData';
+import { removeVolumeLabelmapImageMapperActors } from '../volumeLabelmapImageMapper';
+function removeLabelmapRepresentationFromViewport(viewport, segmentationId) {
+    removeVolumeLabelmapImageMapperActors(viewport, segmentationId);
+    const labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId) ?? [];
+    const legacyActorEntryUIDs = [];
+    labelmapActorEntries.forEach((actorEntry) => {
+        if (removeLabelmapRepresentationData(viewport, segmentationId, actorEntry)) {
+            return;
+        }
+        legacyActorEntryUIDs.push(actorEntry.uid);
+    });
+    if (legacyActorEntryUIDs.length) {
+        viewport.removeActors(legacyActorEntryUIDs);
+    }
+}
+export { removeLabelmapRepresentationFromViewport };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/resolveLabelmapRenderPlan.d.ts

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Segmentation } from '../../../../types/SegmentationStateTypes';
+import type { LabelmapRenderPlan, LabelmapRenderPlanRepresentation } from './types';
+declare function resolveLabelmapRenderPlan({ viewport, segmentation, representation, }: {
+    viewport: Types.IViewport;
+    segmentation: Segmentation;
+    representation: LabelmapRenderPlanRepresentation;
+}): LabelmapRenderPlan;
+export { resolveLabelmapRenderPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/resolveLabelmapRenderPlan.js

@@ -0,0 +1,56 @@
+import getViewportLabelmapRenderMode from '../../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { canRenderVolumeViewportLabelmapAsImage, getVolumeViewportLabelmapImageMapperState, shouldUseSliceRendering, } from '../../../../stateManagement/segmentation/helpers/labelmapImageMapperSupport';
+import { createLabelmapRenderPlan } from './createLabelmapRenderPlan';
+import { createLegacyVolumeLabelmapPlan } from './legacyVolumePlan';
+import { createStackImageLabelmapPlan } from './stackImagePlan';
+import { createVolumeSliceImageMapperPlan } from './volumeSliceImageMapperPlan';
+function resolveLabelmapRenderPlan({ viewport, segmentation, representation, }) {
+    const { segmentationId, config } = representation;
+    const useSliceRendering = shouldUseSliceRendering(segmentation, config);
+    const renderMode = getViewportLabelmapRenderMode(viewport, {
+        useSliceRendering,
+    });
+    const isVolumeImageMapper = useSliceRendering && canRenderVolumeViewportLabelmapAsImage(viewport);
+    if (renderMode === 'unsupported') {
+        return createLabelmapRenderPlan({
+            isVolumeImageMapper,
+            kind: 'unsupported',
+            renderMode,
+            segmentationId,
+            unsupportedStateKey: useSliceRendering
+                ? getVolumeViewportLabelmapImageMapperState(viewport).key
+                : undefined,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    if (isVolumeImageMapper) {
+        return createVolumeSliceImageMapperPlan({
+            isVolumeImageMapper,
+            renderMode,
+            segmentation,
+            segmentationId,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    if (renderMode === 'volume') {
+        return createLegacyVolumeLabelmapPlan({
+            config,
+            isVolumeImageMapper,
+            renderMode,
+            segmentation,
+            segmentationId,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    return createStackImageLabelmapPlan({
+        isVolumeImageMapper,
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+    });
+}
+export { resolveLabelmapRenderPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/stackImagePlan.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ViewportLabelmapRenderMode } from '../../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import type { LabelmapRenderPlan } from './types';
+declare function createStackImageLabelmapPlan({ isVolumeImageMapper, renderMode, segmentationId, useSliceRendering, viewport, }: {
+    isVolumeImageMapper: boolean;
+    renderMode: ViewportLabelmapRenderMode;
+    segmentationId: string;
+    useSliceRendering: boolean;
+    viewport: Types.IViewport;
+}): LabelmapRenderPlan;
+export { createStackImageLabelmapPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/stackImagePlan.js

@@ -0,0 +1,35 @@
+import { getCurrentLabelmapImageIdsForViewport } from '../../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { syncStackLabelmapActors } from '../syncStackLabelmapActors';
+import { createLabelmapRepresentationUID } from '../labelmapRepresentationUID';
+import { createLabelmapRenderPlan } from './createLabelmapRenderPlan';
+function createStackImageLabelmapPlan({ isVolumeImageMapper, renderMode, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'legacy-stack-image',
+        renderMode,
+        segmentationId,
+        updateAfterMount: false,
+        useSliceRendering,
+        viewport,
+        canRenderCurrentViewport: () => hasCurrentStackLabelmapImageIds(viewport, segmentationId),
+        getExpectedRepresentationUIDs: () => getExpectedStackLabelmapRepresentationUIDs(viewport, segmentationId),
+        mount: () => mountStackLabelmapActors(viewport, segmentationId),
+        update: () => syncStackLabelmapActors(viewport, segmentationId),
+    });
+}
+function hasCurrentStackLabelmapImageIds(viewport, segmentationId) {
+    return !!getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId)
+        ?.length;
+}
+function getExpectedStackLabelmapRepresentationUIDs(viewport, segmentationId) {
+    return (getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId)?.map((imageId) => createLabelmapRepresentationUID({
+        segmentationId,
+        referencedId: imageId,
+    })) ?? []);
+}
+async function mountStackLabelmapActors(viewport, segmentationId) {
+    syncStackLabelmapActors(viewport, segmentationId);
+    triggerSegmentationDataModified(segmentationId);
+}
+export { createStackImageLabelmapPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/types.d.ts

@@ -0,0 +1,48 @@
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
+import type { LabelmapRepresentation } from '../../../../types/SegmentationStateTypes';
+import type { ViewportLabelmapRenderMode } from '../../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+type LabelmapRenderPlanKind = 'legacy-volume' | 'legacy-stack-image' | 'volume-slice-image-mapper' | 'unsupported';
+type LabelmapRenderPlanRepresentation = Pick<LabelmapRepresentation, 'segmentationId' | 'config'>;
+type LabelmapRenderPlanMountResult = void | {
+    uid: string;
+    actor: any;
+};
+type LabelmapRenderPlanReconcileArgs = {
+    actorEntries?: Types.ActorEntry[];
+    labelMapData: LabelmapSegmentationData;
+};
+type LabelmapRenderPlanMountArgs = {
+    labelMapData: LabelmapSegmentationData;
+};
+type LabelmapRenderPlanUpdateArgs = {
+    actorEntries?: Types.ActorEntry[];
+};
+type LabelmapRenderPlan = {
+    kind: LabelmapRenderPlanKind;
+    renderMode: ViewportLabelmapRenderMode;
+    useSliceRendering: boolean;
+    isVolumeImageMapper: boolean;
+    unsupportedStateKey?: string;
+    getExpectedRepresentationUIDs: () => string[];
+    mount: (args: LabelmapRenderPlanMountArgs) => Promise<LabelmapRenderPlanMountResult>;
+    needsRemount: (actorEntries?: Types.ActorEntry[]) => boolean;
+    reconcile: (args: LabelmapRenderPlanReconcileArgs) => Promise<Types.ActorEntry[] | undefined>;
+    remove: () => void;
+    update: (args: LabelmapRenderPlanUpdateArgs) => void;
+};
+type CreateLabelmapRenderPlanArgs = {
+    isVolumeImageMapper: boolean;
+    kind: LabelmapRenderPlanKind;
+    renderMode: ViewportLabelmapRenderMode;
+    segmentationId: string;
+    unsupportedStateKey?: string;
+    updateAfterMount?: boolean;
+    useSliceRendering: boolean;
+    viewport: Types.IViewport;
+    canRenderCurrentViewport?: () => boolean;
+    getExpectedRepresentationUIDs?: () => string[];
+    mount?: (args: LabelmapRenderPlanMountArgs) => Promise<LabelmapRenderPlanMountResult>;
+    update?: (args: LabelmapRenderPlanUpdateArgs) => void;
+};
+export type { CreateLabelmapRenderPlanArgs, LabelmapRenderPlan, LabelmapRenderPlanKind, LabelmapRenderPlanMountArgs, LabelmapRenderPlanMountResult, LabelmapRenderPlanRepresentation, LabelmapRenderPlanReconcileArgs, LabelmapRenderPlanUpdateArgs, };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/volumeSliceImageMapperPlan.d.ts

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ViewportLabelmapRenderMode } from '../../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import type { Segmentation } from '../../../../types/SegmentationStateTypes';
+import type { LabelmapRenderPlan } from './types';
+declare function createVolumeSliceImageMapperPlan({ isVolumeImageMapper, renderMode, segmentation, segmentationId, useSliceRendering, viewport, }: {
+    isVolumeImageMapper: boolean;
+    renderMode: ViewportLabelmapRenderMode;
+    segmentation: Segmentation;
+    segmentationId: string;
+    useSliceRendering: boolean;
+    viewport: Types.IViewport;
+}): LabelmapRenderPlan;
+export { createVolumeSliceImageMapperPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/volumeSliceImageMapperPlan.js

@@ -0,0 +1,34 @@
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { addVolumeLabelmapImageMapperActors, getVolumeLabelmapImageMapperRepresentationUIDs, updateVolumeLabelmapImageMapperActors, } from '../volumeLabelmapImageMapper';
+import { createLabelmapRenderPlan } from './createLabelmapRenderPlan';
+function createVolumeSliceImageMapperPlan({ isVolumeImageMapper, renderMode, segmentation, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'volume-slice-image-mapper',
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+        getExpectedRepresentationUIDs: () => getVolumeLabelmapImageMapperRepresentationUIDs(viewport, segmentationId, segmentation),
+        mount: () => mountVolumeLabelmapImageMapper({
+            viewport,
+            segmentation,
+            segmentationId,
+        }),
+        update: ({ actorEntries }) => updateVolumeLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+            actorEntries,
+        }),
+    });
+}
+async function mountVolumeLabelmapImageMapper({ viewport, segmentation, segmentationId, }) {
+    await addVolumeLabelmapImageMapperActors({
+        viewport,
+        segmentation,
+        segmentationId,
+    });
+    triggerSegmentationDataModified(segmentationId);
+}
+export { createVolumeSliceImageMapperPlan };

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan.d.ts

@@ -0,0 +1,2 @@
+export { removeLabelmapRepresentationFromViewport, resolveLabelmapRenderPlan, } from './labelmapRenderPlan/index';
+export type { LabelmapRenderPlan, LabelmapRenderPlanKind, LabelmapRenderPlanMountResult, } from './labelmapRenderPlan/index';

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan.js

@@ -0,0 +1 @@
+export { removeLabelmapRepresentationFromViewport, resolveLabelmapRenderPlan, } from './labelmapRenderPlan/index';

package/dist/esm/tools/displayTools/Labelmap/labelmapRepresentationUID.d.ts

@@ -0,0 +1,8 @@
+declare function getLabelmapRepresentationPrefix(segmentationId: string): string;
+declare function createLabelmapRepresentationUID({ segmentationId, referencedId, sliceStateKey, }: {
+    segmentationId: string;
+    referencedId?: string;
+    sliceStateKey?: string;
+}): string;
+declare function isLabelmapRepresentationUID(representationUID: unknown, segmentationId: string): representationUID is string;
+export { createLabelmapRepresentationUID, getLabelmapRepresentationPrefix, isLabelmapRepresentationUID, };

package/dist/esm/tools/displayTools/Labelmap/labelmapRepresentationUID.js

@@ -0,0 +1,18 @@
+import { SegmentationRepresentations } from '../../../enums';
+function getLabelmapRepresentationPrefix(segmentationId) {
+    return `${segmentationId}-${SegmentationRepresentations.Labelmap}`;
+}
+function createLabelmapRepresentationUID({ segmentationId, referencedId, sliceStateKey, }) {
+    return [
+        getLabelmapRepresentationPrefix(segmentationId),
+        referencedId,
+        sliceStateKey,
+    ]
+        .filter(Boolean)
+        .join('-');
+}
+function isLabelmapRepresentationUID(representationUID, segmentationId) {
+    return (typeof representationUID === 'string' &&
+        representationUID.startsWith(getLabelmapRepresentationPrefix(segmentationId)));
+}
+export { createLabelmapRepresentationUID, getLabelmapRepresentationPrefix, isLabelmapRepresentationUID, };

package/dist/esm/tools/displayTools/Labelmap/removeLabelmapFromElement.js

@@ -1,8 +1,8 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import { getLabelmapActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { removeLabelmapRepresentationFromViewport } from './labelmapRenderPlan';
 function removeLabelmapFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    viewport.removeActors([getLabelmapActorUID(viewport.id, segmentationId)]);
+    removeLabelmapRepresentationFromViewport(viewport, segmentationId);
 }
 export default removeLabelmapFromElement;

package/dist/esm/tools/displayTools/Labelmap/removeLabelmapRepresentationData.d.ts

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+declare function removeLabelmapRepresentationData(viewport: Types.IViewport, segmentationId: string, actorEntry: Types.ActorEntry): boolean;
+export default removeLabelmapRepresentationData;

package/dist/esm/tools/displayTools/Labelmap/removeLabelmapRepresentationData.js

@@ -0,0 +1,16 @@
+import { utilities } from '@cornerstonejs/core';
+import { isLabelmapRepresentationUID } from './labelmapRepresentationUID';
+function removeLabelmapRepresentationData(viewport, segmentationId, actorEntry) {
+    const representationUID = actorEntry.representationUID;
+    if (!isLabelmapRepresentationUID(representationUID, segmentationId)) {
+        return false;
+    }
+    const dataViewport = viewport;
+    if (typeof dataViewport.removeData !== 'function') {
+        return false;
+    }
+    utilities.genericViewportDataSetMetadataProvider.remove(representationUID);
+    dataViewport.removeData(representationUID);
+    return true;
+}
+export default removeLabelmapRepresentationData;

package/dist/esm/tools/displayTools/Labelmap/syncStackLabelmapActors.d.ts

@@ -0,0 +1,2 @@
+import { type Types } from '@cornerstonejs/core';
+export declare function syncStackLabelmapActors(viewport: Types.IStackViewport, segmentationId: string): void;