@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/config.d.ts

@@ -40,9 +40,13 @@ type ComputeWorkerConfig = {
         idleTimeThreshold?: number;
     };
 };
+type SegmentationConfig = {
+    overwriteMode?: 'all' | 'visible' | 'none';
+};
 export type Config = {
     addons: AddOns;
     computeWorker?: ComputeWorkerConfig;
+    segmentation?: SegmentationConfig;
 };
 export declare function getConfig(): Config;
 export declare function setConfig(newConfig: Config): void;

package/dist/esm/drawingSvg/drawPath.d.ts

@@ -4,8 +4,11 @@ export default function drawPath(svgDrawingHelper: SVGDrawingHelper, annotationU
     color?: string;
     fillColor?: string;
     fillOpacity?: number;
+    strokeOpacity?: number;
     width?: number;
     lineWidth?: number;
     lineDash?: string;
+    lineCap?: 'butt' | 'round' | 'square';
+    lineJoin?: 'miter' | 'round' | 'bevel';
     closePath?: boolean;
 }): void;

package/dist/esm/drawingSvg/drawPath.js

@@ -4,7 +4,7 @@ import setAttributesIfNecessary from './setAttributesIfNecessary';
 export default function drawPath(svgDrawingHelper, annotationUID, pathUID, points, options) {
     const hasSubArrays = points.length && points[0].length && Array.isArray(points[0][0]);
     const pointsArrays = hasSubArrays ? points : [points];
-    const { color = 'rgb(0, 255, 0)', width = 10, fillColor = 'none', fillOpacity = 0, lineWidth, lineDash, closePath = false, } = options;
+    const { color = 'rgb(0, 255, 0)', width = 10, fillColor = 'none', fillOpacity = 0, strokeOpacity = 1, lineWidth, lineDash, lineCap, lineJoin, closePath = false, } = options;
     const strokeWidth = lineWidth || width;
     const svgns = 'http://www.w3.org/2000/svg';
     const svgNodeHash = _getHash(annotationUID, 'path', pathUID);
@@ -33,8 +33,11 @@ export default function drawPath(svgDrawingHelper, annotationUID, pathUID, point
         stroke: color,
         fill: fillColor,
         'fill-opacity': fillOpacity,
+        'stroke-opacity': strokeOpacity,
         'stroke-width': strokeWidth,
         'stroke-dasharray': lineDash,
+        'stroke-linecap': lineCap,
+        'stroke-linejoin': lineJoin,
     };
     if (existingNode) {
         setAttributesIfNecessary(attributes, existingNode);

package/dist/esm/eventListeners/keyboard/keyDownListener.js

@@ -1,4 +1,4 @@
-import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import { getEnabledElement, triggerEvent, utilities, } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
 const defaultState = {
     renderingEngineId: undefined,
@@ -52,7 +52,7 @@ function _onKeyUp(evt) {
     document.removeEventListener('keyup', _onKeyUp);
     document.removeEventListener('visibilitychange', _onVisibilityChange);
     state.element.addEventListener('keydown', keyListener);
-    state = structuredClone(defaultState);
+    state = utilities.deepClone(defaultState);
     triggerEvent(eventDetail.element, Events.KEY_UP, eventDetail);
 }
 export function getModifierKey() {

package/dist/esm/eventListeners/mouse/getMouseEventPoints.d.ts

@@ -1,2 +1,2 @@
 import type { IPoints } from '../../types';
-export default function getMouseEventPoints(evt: MouseEvent, element?: HTMLDivElement): IPoints;
+export default function getMouseEventPoints(evt: MouseEvent, element?: HTMLDivElement): IPoints | undefined;

package/dist/esm/eventListeners/mouse/getMouseEventPoints.js

@@ -8,7 +8,10 @@ export default function getMouseEventPoints(evt, element) {
     const clientPoint = _clientToPoint(evt);
     const pagePoint = _pageToPoint(evt);
     const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
-    const worldPoint = viewport.canvasToWorld(canvasPoint);
+    const worldPoint = getWorldPoint(viewport, canvasPoint);
+    if (!worldPoint) {
+        return;
+    }
     return {
         page: pagePoint,
         client: clientPoint,
@@ -29,3 +32,18 @@ function _pageToPoint(evt) {
 function _clientToPoint(evt) {
     return [evt.clientX, evt.clientY];
 }
+function getWorldPoint(viewport, canvasPoint) {
+    try {
+        return viewport.canvasToWorld(canvasPoint);
+    }
+    catch (error) {
+        if (isNoMountedDataError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
+}

package/dist/esm/eventListeners/mouse/mouseDoubleClickListener.js

@@ -3,8 +3,15 @@ import Events from '../../enums/Events';
 import getMouseEventPoints from './getMouseEventPoints';
 function mouseDoubleClickListener(evt) {
     const element = evt.currentTarget;
-    const { viewportId, renderingEngineId } = getEnabledElement(element);
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewportId, renderingEngineId } = enabledElement;
     const startPoints = getMouseEventPoints(evt, element);
+    if (!startPoints) {
+        return;
+    }
     const deltaPoints = {
         page: [0, 0],
         client: [0, 0],

package/dist/esm/eventListeners/mouse/mouseDownListener.js

@@ -1,4 +1,4 @@
-import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import { getEnabledElement, triggerEvent, utilities, } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
 import mouseMoveListener from './mouseMoveListener';
 import getMouseEventPoints from './getMouseEventPoints';
@@ -69,12 +69,21 @@ function mouseDownListener(evt) {
     state.element = evt.currentTarget;
     state.mouseButton = evt.buttons;
     const enabledElement = getEnabledElement(state.element);
+    if (!enabledElement) {
+        state = utilities.deepClone(defaultState);
+        return;
+    }
     const { renderingEngineId, viewportId } = enabledElement;
     state.renderingEngineId = renderingEngineId;
     state.viewportId = viewportId;
     state.preventClickTimeout = setTimeout(_preventClickHandler, state.clickDelay);
-    state.element.removeEventListener('mousemove', mouseMoveListener);
     const startPoints = getMouseEventPoints(evt, state.element);
+    if (!startPoints) {
+        clearTimeout(state.preventClickTimeout);
+        state = utilities.deepClone(defaultState);
+        return;
+    }
+    state.element.removeEventListener('mousemove', mouseMoveListener);
     state.startPoints = _copyPoints(startPoints);
     state.lastPoints = _copyPoints(startPoints);
     document.addEventListener('mouseup', _onMouseUp);
@@ -107,6 +116,9 @@ function _onMouseDrag(evt) {
         return;
     }
     const currentPoints = getMouseEventPoints(evt, state.element);
+    if (!currentPoints) {
+        return;
+    }
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
     if (doubleClickState.doubleClickTimeout) {
@@ -151,6 +163,10 @@ function _onMouseUp(evt) {
     else {
         const eventName = state.isClickEvent ? MOUSE_CLICK : MOUSE_UP;
         const currentPoints = getMouseEventPoints(evt, state.element);
+        if (!currentPoints) {
+            _cleanUp();
+            return;
+        }
         const deltaPoints = _getDeltaPoints(currentPoints, state.lastPoints);
         const eventDetail = {
             event: evt,
@@ -172,6 +188,9 @@ function _onMouseUp(evt) {
 }
 function _onMouseMove(evt) {
     const currentPoints = getMouseEventPoints(evt, state.element);
+    if (!currentPoints) {
+        return;
+    }
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
     if (!_isDragPastDoubleClickTolerance(deltaPoints.canvas)) {
@@ -209,17 +228,26 @@ function _cleanUp() {
     state.element?.removeEventListener('mousemove', _onMouseMove);
     state.element?.addEventListener('mousemove', mouseMoveListener);
     _clearDoubleClickTimeoutAndEvents();
-    state = JSON.parse(JSON.stringify(defaultState));
+    state = utilities.deepClone(defaultState);
 }
 function _copyPoints(points) {
-    return JSON.parse(JSON.stringify(points));
+    return utilities.deepClone(points);
 }
 function _updateMouseEventsLastPoints(element, lastPoints) {
     const { viewport } = getEnabledElement(element) || {};
     if (!viewport) {
         return lastPoints;
     }
-    const world = viewport.canvasToWorld(lastPoints.canvas);
+    let world;
+    try {
+        world = viewport.canvasToWorld(lastPoints.canvas);
+    }
+    catch (error) {
+        if (isNoMountedDataError(error)) {
+            return lastPoints;
+        }
+        throw error;
+    }
     return {
         page: lastPoints.page,
         client: lastPoints.client,
@@ -249,6 +277,10 @@ function _subtractPoints2D(point0, point1) {
 function _subtractPoints3D(point0, point1) {
     return [point0[0] - point1[0], point0[1] - point1[1], point0[2] - point1[2]];
 }
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
+}
 export function getMouseButton() {
     return state.mouseButton;
 }

package/dist/esm/eventListeners/mouse/mouseMoveListener.js

@@ -10,6 +10,9 @@ function mouseMoveListener(evt) {
     }
     const { renderingEngineId, viewportId } = enabledElement;
     const currentPoints = getMouseEventPoints(evt);
+    if (!currentPoints) {
+        return;
+    }
     const eventDetail = {
         renderingEngineId,
         viewportId,

package/dist/esm/eventListeners/segmentation/imageChangeEventListener.js

@@ -1,12 +1,12 @@
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { BaseVolumeViewport, getEnabledElement, Enums, getEnabledElementByIds, cache, utilities, } from '@cornerstonejs/core';
+import { BaseVolumeViewport } from '@cornerstonejs/core';
+import { getEnabledElement, Enums, getEnabledElementByIds, } from '@cornerstonejs/core';
 import { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
-import { updateLabelmapSegmentationImageReferences } from '../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
-import { getCurrentLabelmapImageIdsForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 import { SegmentationRepresentations } from '../../enums';
-import { getLabelmapActorEntries } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { canRenderVolumeViewportLabelmapAsImage, getVolumeViewportLabelmapImageMapperState, shouldUseSliceRendering, } from '../../stateManagement/segmentation/helpers/labelmapImageMapperSupport';
 import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { syncStackLabelmapActors } from '../../tools/displayTools/Labelmap/syncStackLabelmapActors';
 const enable = function (element) {
     if (!element) {
         return;
@@ -16,116 +16,84 @@ const enable = function (element) {
         return;
     }
     const { viewport } = enabledElement;
-    if (viewport instanceof BaseVolumeViewport) {
+    const isVolumeViewport = viewport instanceof BaseVolumeViewport;
+    const isPlanarViewport = viewport.type === Enums.ViewportType.PLANAR_NEXT;
+    const canUseStackImageEvents = typeof viewport
+        .getCurrentImageId === 'function';
+    if (isVolumeViewport || isPlanarViewport) {
+        element.addEventListener(Enums.Events.CAMERA_MODIFIED, _imageChangeEventListener);
+    }
+    if (isVolumeViewport ||
+        !canUseStackImageEvents ||
+        getViewportLabelmapRenderMode(viewport) !== 'image') {
         return;
     }
     element.addEventListener(Enums.Events.PRE_STACK_NEW_IMAGE, _imageChangeEventListener);
     element.addEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
 };
 const disable = function (element) {
+    const viewportId = getEnabledElement(element)?.viewport?.id;
     element.removeEventListener(Enums.Events.PRE_STACK_NEW_IMAGE, _imageChangeEventListener);
     element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
+    element.removeEventListener(Enums.Events.CAMERA_MODIFIED, _imageChangeEventListener);
+    if (viewportId) {
+        perViewportManualTriggers.delete(viewportId);
+    }
 };
 const perViewportManualTriggers = new Map();
 function _imageChangeEventListener(evt) {
     const eventData = evt.detail;
     const { viewportId, renderingEngineId } = eventData;
-    const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
+    const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    const isVolumeViewport = viewport instanceof BaseVolumeViewport;
     const representations = getSegmentationRepresentations(viewportId);
     if (!representations?.length) {
+        perViewportManualTriggers.delete(viewportId);
         return;
     }
     const labelmapRepresentations = representations.filter((representation) => representation.type === SegmentationRepresentations.Labelmap);
-    const actors = viewport.getActors();
-    labelmapRepresentations.forEach((representation) => {
-        const { segmentationId } = representation;
-        updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
+    const hasVolumeImageMapperRepresentation = labelmapRepresentations.some((representation) => {
+        const segmentation = getSegmentation(representation.segmentationId);
+        return (canRenderVolumeViewportLabelmapAsImage(viewport) &&
+            shouldUseSliceRendering(segmentation, representation.config));
     });
-    const labelmapActors = labelmapRepresentations
-        .flatMap((representation) => {
-        return getLabelmapActorEntries(viewportId, representation.segmentationId);
-    })
-        .filter((actor) => actor !== undefined);
-    if (!labelmapActors.length) {
-        return;
-    }
-    labelmapActors.forEach((actor) => {
-        const validActor = labelmapRepresentations.find((representation) => {
-            const derivedImageIds = getCurrentLabelmapImageIdsForViewport(viewportId, representation.segmentationId);
-            return derivedImageIds?.includes(actor.referencedId);
-        });
-        if (!validActor) {
-            viewport.removeActors([actor.uid]);
-        }
-    });
-    labelmapRepresentations.forEach((representation) => {
-        const { segmentationId } = representation;
-        const currentImageId = viewport.getCurrentImageId();
-        const derivedImageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
-        if (!derivedImageIds) {
-            return;
-        }
-        let shouldTriggerSegmentationRender = false;
-        const updateSegmentationActor = (derivedImageId) => {
-            const derivedImage = cache.getImage(derivedImageId);
-            if (!derivedImage) {
-                console.warn('No derived image found in the cache for segmentation representation', representation);
+    if (evt.type === Enums.Events.CAMERA_MODIFIED) {
+        if (hasVolumeImageMapperRepresentation) {
+            const nextState = getVolumeViewportLabelmapImageMapperState(viewport);
+            const previousState = perViewportManualTriggers.get(viewportId);
+            if (previousState === nextState.key) {
                 return;
             }
-            const segmentationActorInput = actors.find((actor) => actor.referencedId === derivedImageId);
-            if (!segmentationActorInput) {
-                const { dimensions, spacing, direction } = viewport.getImageDataMetadata(derivedImage);
-                const currentImage = cache.getImage(currentImageId) ||
-                    {
-                        imageId: currentImageId,
-                    };
-                const { origin: currentOrigin } = viewport.getImageDataMetadata(currentImage);
-                const originToUse = currentOrigin;
-                const constructor = derivedImage.voxelManager.getConstructor();
-                const newPixelData = derivedImage.voxelManager.getScalarData();
-                const scalarArray = vtkDataArray.newInstance({
-                    name: 'Pixels',
-                    numberOfComponents: 1,
-                    values: new constructor(newPixelData),
-                });
-                const imageData = vtkImageData.newInstance();
-                imageData.setDimensions(dimensions[0], dimensions[1], 1);
-                imageData.setSpacing(spacing);
-                imageData.setDirection(direction);
-                imageData.setOrigin(originToUse);
-                imageData.getPointData().setScalars(scalarArray);
-                imageData.modified();
-                viewport.addImages([
-                    {
-                        imageId: derivedImageId,
-                        representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}-${derivedImage.imageId}`,
-                        callback: ({ imageActor }) => {
-                            imageActor.getMapper().setInputData(imageData);
-                        },
-                    },
-                ]);
-                shouldTriggerSegmentationRender = true;
-                return;
-            }
-            else {
-                const segmentationImageData = segmentationActorInput.actor
-                    .getMapper()
-                    .getInputData();
-                if (segmentationImageData.setDerivedImage) {
-                    segmentationImageData.setDerivedImage(derivedImage);
-                }
-                else {
-                    utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
-                }
-            }
-        };
-        derivedImageIds.forEach(updateSegmentationActor);
-        if (shouldTriggerSegmentationRender) {
+            perViewportManualTriggers.set(viewportId, nextState.key);
             triggerSegmentationRender(viewportId);
+            return;
         }
-        viewport.render();
+        const isPlanarNext = viewport.type === Enums.ViewportType.PLANAR_NEXT;
+        if (!isPlanarNext) {
+            perViewportManualTriggers.delete(viewportId);
+            return;
+        }
+    }
+    if (getViewportLabelmapRenderMode(viewport) !== 'image') {
+        return;
+    }
+    if (canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return;
+    }
+    if (typeof viewport
+        .getCurrentImageId !== 'function') {
+        return;
+    }
+    const stackViewport = viewport;
+    labelmapRepresentations.forEach((representation) => {
+        const { segmentationId } = representation;
+        syncStackLabelmapActors(stackViewport, segmentationId);
         if (evt.type === Enums.Events.IMAGE_RENDERED) {
-            viewport.element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
+            stackViewport.element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
         }
     });
 }

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.js

@@ -1,9 +1,13 @@
-import { VolumeViewport, getEnabledElementByViewportId, StackViewport, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../../enums';
 import { performVolumeLabelmapUpdate } from './performVolumeLabelmapUpdate';
 import { performStackLabelmapUpdate } from './performStackLabelmapUpdate';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { getViewportIdsWithSegmentation } from '../../../stateManagement/segmentation/getViewportIdsWithSegmentation';
+import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
+import getViewportLabelmapRenderMode from '../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { triggerSegmentationRender } from '../../../stateManagement/segmentation/SegmentationRenderingEngine';
+import { canRenderVolumeViewportLabelmapAsImage, shouldUseSliceRendering, } from '../../../stateManagement/segmentation/helpers/labelmapImageMapperSupport';
 const getViewportByViewportId = (viewportId) => {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     return enabledElement?.viewport ?? undefined;
@@ -12,30 +16,54 @@ const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
     const { representationData } = getSegmentation(segmentationId);
     const viewportIds = getViewportIdsWithSegmentation(segmentationId);
-    const hasVolumeViewport = viewportIds.some((viewportId) => {
-        const viewport = getViewportByViewportId(viewportId);
-        return viewport instanceof VolumeViewport;
-    });
-    const hasStackViewport = viewportIds.some((viewportId) => {
-        const viewport = getViewportByViewportId(viewportId);
-        return viewport instanceof StackViewport;
-    });
-    const hasBothStackAndVolume = hasVolumeViewport && hasStackViewport;
+    const volumeViewportIds = [];
+    const stackViewportIds = [];
+    const imageMapperViewportIds = [];
     viewportIds.forEach((viewportId) => {
         const viewport = getViewportByViewportId(viewportId);
-        if (viewport instanceof VolumeViewport) {
-            performVolumeLabelmapUpdate({
-                modifiedSlicesToUse: hasBothStackAndVolume ? [] : modifiedSlicesToUse,
-                representationData,
-                type: SegmentationRepresentations.Labelmap,
-            });
+        if (!viewport) {
+            return;
+        }
+        const labelmapRepresentation = getSegmentationRepresentations(viewportId, {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        })[0];
+        const useSliceRendering = shouldUseSliceRendering(getSegmentation(segmentationId), labelmapRepresentation?.config);
+        const renderMode = getViewportLabelmapRenderMode(viewport, {
+            useSliceRendering,
+        });
+        if (renderMode === 'volume') {
+            volumeViewportIds.push(viewportId);
+            return;
         }
-        if (viewport instanceof StackViewport) {
-            performStackLabelmapUpdate({
-                viewportIds,
-                segmentationId,
-            });
+        if (renderMode === 'image') {
+            if (useSliceRendering &&
+                canRenderVolumeViewportLabelmapAsImage(viewport)) {
+                imageMapperViewportIds.push(viewportId);
+            }
+            else {
+                stackViewportIds.push(viewportId);
+            }
         }
     });
+    const hasVolumeViewport = volumeViewportIds.length > 0;
+    const hasStackViewport = stackViewportIds.length > 0;
+    const hasBothStackAndVolume = hasVolumeViewport && hasStackViewport;
+    if (hasVolumeViewport) {
+        performVolumeLabelmapUpdate({
+            modifiedSlicesToUse: hasBothStackAndVolume ? [] : modifiedSlicesToUse,
+            representationData,
+            type: SegmentationRepresentations.Labelmap,
+        });
+    }
+    if (hasStackViewport) {
+        performStackLabelmapUpdate({
+            viewportIds: stackViewportIds,
+            segmentationId,
+        });
+    }
+    imageMapperViewportIds.forEach((viewportId) => {
+        triggerSegmentationRender(viewportId);
+    });
 };
 export default onLabelmapSegmentationDataModified;

package/dist/esm/eventListeners/segmentation/labelmap/performStackLabelmapUpdate.js

@@ -1,8 +1,8 @@
-import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../../enums';
-import { getLabelmapActorEntries } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
-import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import getViewportLabelmapRenderMode from '../../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { syncStackLabelmapActors } from '../../../tools/displayTools/Labelmap/syncStackLabelmapActors';
 export function performStackLabelmapUpdate({ viewportIds, segmentationId, }) {
     viewportIds.forEach((viewportId) => {
         let representations = getSegmentationRepresentations(viewportId, {
@@ -18,20 +18,14 @@ export function performStackLabelmapUpdate({ viewportIds, segmentationId, }) {
                 return;
             }
             const { viewport } = enabledElement;
-            if (viewport instanceof VolumeViewport) {
+            if (getViewportLabelmapRenderMode(viewport) !== 'image') {
                 return;
             }
-            const actorEntries = getLabelmapActorEntries(viewportId, segmentationId);
-            if (!actorEntries?.length) {
+            if (typeof viewport
+                .getCurrentImageId !== 'function') {
                 return;
             }
-            actorEntries.forEach((actorEntry, i) => {
-                const segImageData = actorEntry.actor.getMapper().getInputData();
-                const currentSegmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
-                const segmentationImage = cache.getImage(currentSegmentationImageIds[i]);
-                segImageData.modified();
-                csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);
-            });
+            syncStackLabelmapActors(viewport, segmentationId);
         });
     });
 }

package/dist/esm/eventListeners/segmentation/labelmap/performVolumeLabelmapUpdate.js

@@ -1,21 +1,47 @@
-import { cache } from '@cornerstonejs/core';
+import { cache, eventTarget, triggerEvent, Enums } from '@cornerstonejs/core';
+import { getOrCreateLabelmapVolume } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData, type, }) {
-    const segmentationVolume = cache.getVolume(representationData[type].volumeId);
-    if (!segmentationVolume) {
-        console.warn('segmentation not found in cache');
-        return;
-    }
-    const { imageData, vtkOpenGLTexture } = segmentationVolume;
-    let slicesToUpdate;
-    if (modifiedSlicesToUse?.length > 0) {
-        slicesToUpdate = modifiedSlicesToUse;
-    }
-    else {
-        const numSlices = imageData.getDimensions()[2];
-        slicesToUpdate = [...Array(numSlices).keys()];
-    }
-    slicesToUpdate.forEach((i) => {
-        vtkOpenGLTexture.setUpdatedFrame(i);
+    const labelmapData = representationData[type];
+    const volumes = getVolumesToUpdate(labelmapData);
+    volumes.forEach((segmentationVolume) => {
+        const { imageData, vtkOpenGLTexture, voxelManager } = segmentationVolume;
+        let slicesToUpdate;
+        if (modifiedSlicesToUse?.length > 0) {
+            slicesToUpdate = modifiedSlicesToUse;
+        }
+        else {
+            const numSlices = imageData.getDimensions()[2];
+            slicesToUpdate = [...Array(numSlices).keys()];
+        }
+        vtkOpenGLTexture?.setUpdatedFrame &&
+            slicesToUpdate.forEach((i) => {
+                vtkOpenGLTexture.setUpdatedFrame(i);
+            });
+        voxelManager?.invalidateCache?.();
+        imageData.modified();
+        const numberOfFrames = segmentationVolume.imageIds?.length ?? imageData.getDimensions()[2] ?? 0;
+        const FrameOfReferenceUID = segmentationVolume.metadata?.FrameOfReferenceUID ?? '';
+        triggerEvent(eventTarget, Enums.Events.IMAGE_VOLUME_MODIFIED, {
+            volumeId: segmentationVolume.volumeId,
+            FrameOfReferenceUID,
+            numberOfFrames,
+            framesProcessed: numberOfFrames,
+        });
     });
-    imageData.modified();
+}
+function getVolumesToUpdate(labelmapData) {
+    const volumes = [];
+    const seenVolumeIds = new Set();
+    const addVolume = (volume) => {
+        if (!volume?.volumeId || seenVolumeIds.has(volume.volumeId)) {
+            return;
+        }
+        seenVolumeIds.add(volume.volumeId);
+        volumes.push(volume);
+    };
+    Object.values(labelmapData?.labelmaps ?? {}).forEach((layer) => {
+        addVolume(getOrCreateLabelmapVolume(layer));
+    });
+    addVolume(labelmapData?.volumeId && cache.getVolume(labelmapData.volumeId));
+    return volumes;
 }