@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

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

@@ -0,0 +1,191 @@
+import { ActorRenderMode } from '@cornerstonejs/core';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
+import { getSegmentBinding } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
+import { getLabelmapForActorReference } from './volumeLabelmapImageMapper';
+const actorTransferFunctions = new WeakMap();
+const MAX_NUMBER_COLORS = 255;
+function setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentationRepresentation) {
+    const { segmentationId } = segmentationRepresentation;
+    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 segmentation = getSegmentation(segmentationId);
+    const layer = getLabelmapForActorReference(segmentation, labelmapActorEntry.referencedId);
+    const layerBindings = Object.keys(segmentation.segments)
+        .map(Number)
+        .map((segmentIndex) => ({
+        segmentIndex,
+        binding: getSegmentBinding(segmentation, segmentIndex),
+    }))
+        .filter((entry) => !layer || entry.binding?.labelmapId === layer.labelmapId);
+    const maxLabelValue = Math.max(1, ...layerBindings.map((entry) => entry.binding?.labelValue ?? entry.segmentIndex));
+    const numColors = Math.max(colorLUT.length, maxLabelValue + 1);
+    const labelValueEntries = Array.from({ length: numColors - 1 }, (_, index) => {
+        const labelValue = index + 1;
+        const segmentIndex = layer?.labelToSegmentIndex?.[labelValue] ?? labelValue;
+        return {
+            labelValue,
+            segmentIndex,
+        };
+    });
+    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = getLabelmapConfig(labelmapStyle, isActiveLabelmap);
+    const segmentsHidden = internalGetHiddenSegmentIndices(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
+    const labelmapActor = labelmapActorEntry.actor;
+    const { cfun, ofun } = getOrCreateTransferFunctions(labelmapActor);
+    cfun.removeAllPoints();
+    ofun.removeAllPoints();
+    const colorNodes = [
+        { x: 0, r: 0, g: 0, b: 0, midpoint: 0.5, sharpness: 1.0 },
+    ];
+    const opacityNodes = [{ x: 0, y: 0, midpoint: 0.5, sharpness: 1.0 }];
+    labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+        const segmentColor = colorLUT[segmentIndex];
+        if (!segmentColor) {
+            return;
+        }
+        const perSegmentStyle = segmentationStyle.getStyle({
+            viewportId,
+            type: SegmentationRepresentations.Labelmap,
+            segmentationId,
+            segmentIndex,
+        });
+        const { fillAlpha, renderFill } = getLabelmapConfig(labelmapStyle, isActiveLabelmap, perSegmentStyle);
+        colorNodes.push({
+            x: labelValue,
+            r: segmentColor[0] / MAX_NUMBER_COLORS,
+            g: segmentColor[1] / MAX_NUMBER_COLORS,
+            b: segmentColor[2] / MAX_NUMBER_COLORS,
+            midpoint: 0.5,
+            sharpness: 1.0,
+        });
+        if (renderFill) {
+            const segmentOpacity = segmentsHidden.has(segmentIndex)
+                ? 0
+                : (segmentColor[3] / 255) * fillAlpha;
+            opacityNodes.push({
+                x: labelValue,
+                y: segmentOpacity,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+        else {
+            opacityNodes.push({
+                x: labelValue,
+                y: 0.01,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+    });
+    cfun.setNodes(colorNodes);
+    ofun.setNodes(opacityNodes);
+    ofun.setClamping(false);
+    const actorMapper = labelmapActorEntry.actorMapper;
+    const labelmapMapper = actorMapper?.mapper
+        ? actorMapper.mapper
+        : labelmapActor.getMapper();
+    const { preLoad } = labelmapActor.get?.('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        labelmapActor.getProperty().setScalarOpacity(0, ofun);
+        labelmapActor.getProperty().setInterpolationTypeToNearest();
+    }
+    if (labelmapActorEntry.actorMapper?.renderMode === ActorRenderMode.VTK_IMAGE ||
+        labelmapActorEntry.actorMapper?.renderMode ===
+            ActorRenderMode.VTK_VOLUME_SLICE) {
+        const imageSlice = labelmapActor;
+        imageSlice.setForceTranslucent(true);
+        imageSlice.setForceOpaque(false);
+        imageSlice.getProperty().setUseLookupTableScalarRange(true);
+    }
+    if (renderOutline) {
+        labelmapActor.getProperty().setUseLabelOutline(renderOutline);
+        labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+        const activeSegmentIndex = getActiveSegmentIndex(segmentationRepresentation.segmentationId);
+        const outlineWidths = new Array(numColors - 1).fill(0);
+        labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+            const isHidden = segmentsHidden.has(segmentIndex);
+            if (isHidden) {
+                return;
+            }
+            outlineWidths[labelValue - 1] =
+                segmentIndex === activeSegmentIndex
+                    ? outlineWidth + activeSegmentOutlineWidthDelta
+                    : outlineWidth;
+        });
+        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+        labelmapActor.modified();
+        labelmapActor.getProperty().modified();
+        labelmapMapper?.modified?.();
+    }
+    else {
+        labelmapActor
+            .getProperty()
+            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
+    }
+    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    labelmapActor.setVisibility(visible);
+    labelmapActor.modified();
+    labelmapActor.getProperty().modified();
+    labelmapMapper?.modified?.();
+}
+function getOrCreateTransferFunctions(actor) {
+    const existing = actorTransferFunctions.get(actor);
+    if (existing) {
+        return existing;
+    }
+    const cfun = vtkColorTransferFunction.newInstance();
+    const ofun = vtkPiecewiseFunction.newInstance();
+    ofun.addPoint(0, 0);
+    const created = { cfun, ofun };
+    actorTransferFunctions.set(actor, created);
+    return created;
+}
+function getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
+    const segmentLabelmapConfig = segmentsLabelmapConfig || {};
+    const configToUse = {
+        ...labelmapConfig,
+        ...segmentLabelmapConfig,
+    };
+    return {
+        fillAlpha: isActiveLabelmap
+            ? configToUse.fillAlpha
+            : configToUse.fillAlphaInactive,
+        outlineWidth: isActiveLabelmap
+            ? configToUse.outlineWidth
+            : configToUse.outlineWidthInactive,
+        renderFill: isActiveLabelmap
+            ? configToUse.renderFill
+            : configToUse.renderFillInactive,
+        renderOutline: isActiveLabelmap
+            ? configToUse.renderOutline
+            : configToUse.renderOutlineInactive,
+        outlineOpacity: isActiveLabelmap
+            ? configToUse.outlineOpacity
+            : configToUse.outlineOpacityInactive,
+        activeSegmentOutlineWidthDelta: configToUse.activeSegmentOutlineWidthDelta,
+    };
+}
+export { MAX_NUMBER_COLORS, setLabelmapColorAndOpacity };

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

@@ -1,9 +1,10 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-export declare const MAX_NUMBER_COLORS = 255;
+import { MAX_NUMBER_COLORS } from './labelmapActorStyle';
+export { MAX_NUMBER_COLORS };
 declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
-declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
-declare function getUpdateFunction(viewport: Types.IVolumeViewport | Types.IStackViewport): (segmentationId: string) => Promise<void> | null;
+declare function render(viewport: Types.IViewport, representation: LabelmapRepresentation): Promise<void>;
+declare function getUpdateFunction(_viewport: Types.IViewport): (segmentationId: string) => Promise<void> | null;
 declare const _default: {
     getUpdateFunction: typeof getUpdateFunction;
     render: typeof render;

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