@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -1,41 +1,31 @@
-import { getEnabledElementByViewportId, VolumeViewport, } from '@cornerstonejs/core';
-import addLabelmapToElement from './addLabelmapToElement';
-import removeLabelmapFromElement from './removeLabelmapFromElement';
-import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
-import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
-import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { Enums as CoreEnums, eventTarget, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
-import { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
 import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
-import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLabelmapActorEntries } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 import { getPolySeg } from '../../../config';
 import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { defaultSegmentationStateManager } from '../../../stateManagement/segmentation/SegmentationStateManager';
-export const MAX_NUMBER_COLORS = 255;
-const labelMapConfigCache = new Map();
+import { removeLabelmapRepresentationFromViewport, resolveLabelmapRenderPlan, } from './labelmapRenderPlan';
+import { MAX_NUMBER_COLORS, setLabelmapColorAndOpacity, } from './labelmapActorStyle';
+export { MAX_NUMBER_COLORS };
+const unsupportedImageMapperStates = new Map();
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    clearUnsupportedImageMapperError(viewportId, segmentationId);
     const enabledElement = getEnabledElementByViewportId(viewportId);
-    labelMapConfigCache.forEach((value, key) => {
-        if (key.includes(segmentationId)) {
-            labelMapConfigCache.delete(key);
-        }
-    });
     if (!enabledElement) {
         return;
     }
     const { viewport } = enabledElement;
-    removeLabelmapFromElement(viewport.element, segmentationId);
+    removeLabelmapRepresentationFromViewport(viewport, segmentationId);
     if (!renderImmediate) {
         return;
     }
     viewport.render();
 }
 async function render(viewport, representation) {
-    const { segmentationId, config } = representation;
+    const { segmentationId } = representation;
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
@@ -48,7 +38,9 @@ async function render(viewport, representation) {
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         const polySeg = getPolySeg();
-        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, { viewport }), () => {
+        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, {
+            viewport: viewport,
+        }), () => {
             defaultSegmentationStateManager.processLabelmapRepresentationAddition(viewport.id, segmentationId);
             setTimeout(() => {
                 triggerSegmentationDataModified(segmentationId);
@@ -65,208 +57,55 @@ async function render(viewport, representation) {
     if (!labelmapData) {
         return;
     }
-    if (viewport instanceof VolumeViewport) {
-        if (!labelmapActorEntries?.length) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
-        }
-        labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
-    }
-    else {
-        const labelmapImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId);
-        if (!labelmapImageIds?.length) {
-            return;
+    const renderPlan = resolveLabelmapRenderPlan({
+        viewport,
+        segmentation,
+        representation,
+    });
+    if (renderPlan.kind === 'unsupported') {
+        if (labelmapActorEntries?.length) {
+            renderPlan.remove();
         }
-        if (!labelmapActorEntries) {
-            await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
+        if (renderPlan.unsupportedStateKey) {
+            reportUnsupportedImageMapperError(viewport.id, segmentationId, renderPlan.unsupportedStateKey);
         }
-        labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
+        return;
     }
+    clearUnsupportedImageMapperError(viewport.id, segmentationId);
+    labelmapActorEntries = await renderPlan.reconcile({
+        actorEntries: labelmapActorEntries,
+        labelMapData: labelmapData,
+    });
     if (!labelmapActorEntries?.length) {
         return;
     }
     for (const labelmapActorEntry of labelmapActorEntries) {
-        _setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
-    }
-}
-function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentationRepresentation) {
-    const { segmentationId } = segmentationRepresentation;
-    const { cfun, ofun } = segmentationRepresentation.config;
-    const { colorLUTIndex } = segmentationRepresentation;
-    const activeSegmentation = getActiveSegmentation(viewportId);
-    const isActiveLabelmap = activeSegmentation?.segmentationId === segmentationId;
-    const labelmapStyle = segmentationStyle.getStyle({
-        viewportId,
-        type: SegmentationRepresentations.Labelmap,
-        segmentationId,
-    });
-    const renderInactiveSegmentations = segmentationStyle.getRenderInactiveSegmentations(viewportId);
-    const colorLUT = getColorLUT(colorLUTIndex);
-    const numColors = Math.min(256, colorLUT.length);
-    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapStyle, isActiveLabelmap);
-    const segmentsHidden = internalGetHiddenSegmentIndices(viewportId, {
-        segmentationId,
-        type: SegmentationRepresentations.Labelmap,
-    });
-    for (let i = 0; i < numColors; i++) {
-        const segmentIndex = i;
-        const segmentColor = colorLUT[segmentIndex];
-        const perSegmentStyle = segmentationStyle.getStyle({
-            viewportId,
-            type: SegmentationRepresentations.Labelmap,
-            segmentationId,
-            segmentIndex,
-        });
-        const segmentSpecificLabelmapConfig = perSegmentStyle;
-        const { fillAlpha, outlineWidth, renderFill, renderOutline } = _getLabelmapConfig(labelmapStyle, isActiveLabelmap, segmentSpecificLabelmapConfig);
-        const { forceOpacityUpdate, forceColorUpdate } = _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex, {
-            fillAlpha,
-            renderFill,
-            renderOutline,
-            segmentColor,
-            outlineWidth,
-            segmentsHidden: segmentsHidden,
-            cfun,
-            ofun,
-        });
-        if (forceColorUpdate) {
-            cfun.addRGBPoint(segmentIndex, segmentColor[0] / MAX_NUMBER_COLORS, segmentColor[1] / MAX_NUMBER_COLORS, segmentColor[2] / MAX_NUMBER_COLORS);
-        }
-        if (forceOpacityUpdate) {
-            if (renderFill) {
-                const segmentOpacity = segmentsHidden.has(segmentIndex)
-                    ? 0
-                    : (segmentColor[3] / 255) * fillAlpha;
-                ofun.removePoint(segmentIndex);
-                ofun.addPointLong(segmentIndex, segmentOpacity, 0.5, 1.0);
-            }
-            else {
-                ofun.addPointLong(segmentIndex, 0.01, 0.5, 1.0);
-            }
-        }
-    }
-    ofun.setClamping(false);
-    const labelmapActor = labelmapActorEntry.actor;
-    const { preLoad } = labelmapActor.get?.('preLoad') || { preLoad: null };
-    if (preLoad) {
-        preLoad({ cfun, ofun, actor: labelmapActor });
+        setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
     }
-    else {
-        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
-        labelmapActor.getProperty().setScalarOpacity(0, ofun);
-        labelmapActor.getProperty().setInterpolationTypeToNearest();
-    }
-    if (renderOutline) {
-        labelmapActor.getProperty().setUseLabelOutline(renderOutline);
-        labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-        const activeSegmentIndex = getActiveSegmentIndex(segmentationRepresentation.segmentationId);
-        const outlineWidths = new Array(numColors - 1);
-        for (let i = 1; i < numColors; i++) {
-            const isHidden = segmentsHidden.has(i);
-            if (isHidden) {
-                outlineWidths[i - 1] = 0;
-                continue;
-            }
-            outlineWidths[i - 1] =
-                i === activeSegmentIndex
-                    ? outlineWidth + activeSegmentOutlineWidthDelta
-                    : outlineWidth;
-        }
-        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
-        labelmapActor.modified();
-        labelmapActor.getProperty().modified();
-        labelmapActor.getMapper().modified();
-    }
-    else {
-        labelmapActor
-            .getProperty()
-            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
-    }
-    const visible = isActiveLabelmap || renderInactiveSegmentations;
-    labelmapActor.setVisibility(visible);
 }
-function _getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
-    const segmentLabelmapConfig = segmentsLabelmapConfig || {};
-    const configToUse = {
-        ...labelmapConfig,
-        ...segmentLabelmapConfig,
-    };
-    const fillAlpha = isActiveLabelmap
-        ? configToUse.fillAlpha
-        : configToUse.fillAlphaInactive;
-    const outlineWidth = isActiveLabelmap
-        ? configToUse.outlineWidth
-        : configToUse.outlineWidthInactive;
-    const renderFill = isActiveLabelmap
-        ? configToUse.renderFill
-        : configToUse.renderFillInactive;
-    const renderOutline = isActiveLabelmap
-        ? configToUse.renderOutline
-        : configToUse.renderOutlineInactive;
-    const outlineOpacity = isActiveLabelmap
-        ? configToUse.outlineOpacity
-        : configToUse.outlineOpacityInactive;
-    const activeSegmentOutlineWidthDelta = configToUse.activeSegmentOutlineWidthDelta;
-    return {
-        fillAlpha,
-        outlineWidth,
-        renderFill,
-        renderOutline,
-        outlineOpacity,
-        activeSegmentOutlineWidthDelta,
-    };
+function getUpdateFunction(_viewport) {
+    return;
 }
-function _needsTransferFunctionUpdate(viewportId, segmentationId, segmentIndex, { fillAlpha, renderFill, renderOutline, segmentColor, outlineWidth, segmentsHidden, cfun, ofun, }) {
-    const cacheUID = `${viewportId}-${segmentationId}-${segmentIndex}`;
-    const oldConfig = labelMapConfigCache.get(cacheUID);
-    if (!oldConfig) {
-        labelMapConfigCache.set(cacheUID, {
-            fillAlpha,
-            renderFill,
-            renderOutline,
-            outlineWidth,
-            segmentColor: segmentColor.slice(),
-            segmentsHidden: new Set(segmentsHidden),
-            cfunMTime: cfun.getMTime(),
-            ofunMTime: ofun.getMTime(),
-        });
-        return {
-            forceOpacityUpdate: true,
-            forceColorUpdate: true,
-        };
-    }
-    const { fillAlpha: oldFillAlpha, renderFill: oldRenderFill, renderOutline: oldRenderOutline, outlineWidth: oldOutlineWidth, segmentColor: oldSegmentColor, segmentsHidden: oldSegmentsHidden, cfunMTime: oldCfunMTime, ofunMTime: oldOfunMTime, } = oldConfig;
-    const forceColorUpdate = oldSegmentColor[0] !== segmentColor[0] ||
-        oldSegmentColor[1] !== segmentColor[1] ||
-        oldSegmentColor[2] !== segmentColor[2];
-    const forceOpacityUpdate = oldSegmentColor[3] !== segmentColor[3] ||
-        oldFillAlpha !== fillAlpha ||
-        oldRenderFill !== renderFill ||
-        oldRenderOutline !== renderOutline ||
-        oldOutlineWidth !== outlineWidth ||
-        oldSegmentsHidden !== segmentsHidden;
-    if (forceOpacityUpdate || forceColorUpdate) {
-        labelMapConfigCache.set(cacheUID, {
-            fillAlpha,
-            renderFill,
-            renderOutline,
-            outlineWidth,
-            segmentColor: segmentColor.slice(),
-            segmentsHidden: new Set(segmentsHidden),
-            cfunMTime: cfun.getMTime(),
-            ofunMTime: ofun.getMTime(),
-        });
-    }
-    return {
-        forceOpacityUpdate,
-        forceColorUpdate,
-    };
+function getUnsupportedImageMapperStateKey(viewportId, segmentationId) {
+    return `${viewportId}:${segmentationId}`;
 }
-async function _addLabelmapToViewport(viewport, labelmapData, segmentationId, config) {
-    const result = await addLabelmapToElement(viewport.element, labelmapData, segmentationId, config);
-    return result || undefined;
+function clearUnsupportedImageMapperError(viewportId, segmentationId) {
+    unsupportedImageMapperStates.delete(getUnsupportedImageMapperStateKey(viewportId, segmentationId));
 }
-function getUpdateFunction(viewport) {
-    return;
+function reportUnsupportedImageMapperError(viewportId, segmentationId, stateKey) {
+    const cacheKey = getUnsupportedImageMapperStateKey(viewportId, segmentationId);
+    const previousStateKey = unsupportedImageMapperStates.get(cacheKey);
+    if (previousStateKey === stateKey) {
+        return;
+    }
+    unsupportedImageMapperStates.set(cacheKey, stateKey);
+    eventTarget.dispatchEvent(new CustomEvent(CoreEnums.Events.ERROR_EVENT, {
+        detail: {
+            type: 'Segmentation',
+            message: 'Labelmap image-mapper rendering is only supported on legacy orthographic single-slice volume viewports.',
+        },
+        cancelable: true,
+    }));
 }
 export default {
     getUpdateFunction,

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

@@ -0,0 +1,3 @@
+import type { CreateLabelmapRenderPlanArgs, LabelmapRenderPlan } from './types';
+declare function createLabelmapRenderPlan({ isVolumeImageMapper, kind, renderMode, segmentationId, unsupportedStateKey, updateAfterMount, useSliceRendering, viewport, canRenderCurrentViewport, getExpectedRepresentationUIDs, mount, update, }: CreateLabelmapRenderPlanArgs): LabelmapRenderPlan;
+export { createLabelmapRenderPlan };

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

@@ -0,0 +1,51 @@
+import { getLabelmapActorEntries } from '../../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { removeLabelmapRepresentationFromViewport } from './removeLabelmapRepresentationFromViewport';
+function createLabelmapRenderPlan({ isVolumeImageMapper, kind, renderMode, segmentationId, unsupportedStateKey, updateAfterMount = true, useSliceRendering, viewport, canRenderCurrentViewport = () => kind !== 'unsupported', getExpectedRepresentationUIDs = () => [], mount = async () => undefined, update = () => undefined, }) {
+    const remove = () => removeLabelmapRepresentationFromViewport(viewport, segmentationId);
+    const needsRemount = (actorEntries) => haveActorUIDsChanged(actorEntries, getExpectedRepresentationUIDs());
+    return {
+        kind,
+        renderMode,
+        useSliceRendering,
+        isVolumeImageMapper,
+        unsupportedStateKey,
+        getExpectedRepresentationUIDs,
+        mount,
+        needsRemount,
+        remove,
+        update,
+        reconcile: async ({ actorEntries, labelMapData }) => {
+            if (!canRenderCurrentViewport()) {
+                return actorEntries;
+            }
+            let nextActorEntries = actorEntries;
+            if (needsRemount(nextActorEntries) && nextActorEntries?.length) {
+                remove();
+                nextActorEntries = undefined;
+            }
+            const mounted = !nextActorEntries?.length;
+            if (mounted) {
+                await mount({ labelMapData });
+            }
+            nextActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
+            if (nextActorEntries?.length && (!mounted || updateAfterMount)) {
+                update({ actorEntries: nextActorEntries });
+            }
+            return nextActorEntries;
+        },
+    };
+}
+function haveActorUIDsChanged(actorEntries, expectedRepresentationUIDs) {
+    const actualUIDs = new Set((actorEntries ?? []).map((entry) => entry.representationUID));
+    const expectedUIDs = new Set(expectedRepresentationUIDs);
+    if (actualUIDs.size !== expectedUIDs.size) {
+        return true;
+    }
+    for (const expectedUID of expectedUIDs) {
+        if (!actualUIDs.has(expectedUID)) {
+            return true;
+        }
+    }
+    return false;
+}
+export { createLabelmapRenderPlan };

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

@@ -0,0 +1,4 @@
+export { createLabelmapRenderPlan } from './createLabelmapRenderPlan';
+export { removeLabelmapRepresentationFromViewport } from './removeLabelmapRepresentationFromViewport';
+export { resolveLabelmapRenderPlan } from './resolveLabelmapRenderPlan';
+export type { LabelmapRenderPlan, LabelmapRenderPlanKind, LabelmapRenderPlanMountResult, } from './types';

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

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

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

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

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