@cornerstonejs/tools 3.3.3 → 3.4.0

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

@@ -3,9 +3,9 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { BaseVolumeViewport, getEnabledElement, Enums, getEnabledElementByIds, cache, utilities, } from '@cornerstonejs/core';
 import { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import { updateLabelmapSegmentationImageReferences } from '../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
-import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getCurrentLabelmapImageIdsForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 import { SegmentationRepresentations } from '../../enums';
-import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getLabelmapActorEntries } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
 import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
 const enable = function (element) {
     if (!element) {
@@ -42,8 +42,8 @@ function _imageChangeEventListener(evt) {
         updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
     });
     const labelmapActors = labelmapRepresentations
-        .map((representation) => {
-        return getLabelmapActorEntry(viewportId, representation.segmentationId);
+        .flatMap((representation) => {
+        return getLabelmapActorEntries(viewportId, representation.segmentationId);
     })
         .filter((actor) => actor !== undefined);
     if (!labelmapActors.length) {
@@ -51,8 +51,8 @@ function _imageChangeEventListener(evt) {
     }
     labelmapActors.forEach((actor) => {
         const validActor = labelmapRepresentations.find((representation) => {
-            const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
-            return derivedImageId === actor.referencedId;
+            const derivedImageIds = getCurrentLabelmapImageIdsForViewport(viewportId, representation.segmentationId);
+            return derivedImageIds?.includes(actor.referencedId);
         });
         if (!validActor) {
             viewport.removeActors([actor.uid]);
@@ -61,61 +61,64 @@ function _imageChangeEventListener(evt) {
     labelmapRepresentations.forEach((representation) => {
         const { segmentationId } = representation;
         const currentImageId = viewport.getCurrentImageId();
-        const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
-        if (!derivedImageId) {
+        const derivedImageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+        if (!derivedImageIds) {
             return;
         }
-        const derivedImage = cache.getImage(derivedImageId);
-        if (!derivedImage) {
-            console.warn('No derived image found in the cache for segmentation representation', representation);
-            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}`,
-                    callback: ({ imageActor }) => {
-                        imageActor.getMapper().setInputData(imageData);
+        const updateSegmentationActor = (derivedImageId) => {
+            const derivedImage = cache.getImage(derivedImageId);
+            if (!derivedImage) {
+                console.warn('No derived image found in the cache for segmentation representation', representation);
+                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);
+                        },
                     },
-                },
-            ]);
-            triggerSegmentationRender(viewportId);
-            return;
-        }
-        else {
-            const segmentationImageData = segmentationActorInput.actor
-                .getMapper()
-                .getInputData();
-            if (segmentationImageData.setDerivedImage) {
-                segmentationImageData.setDerivedImage(derivedImage);
+                ]);
+                triggerSegmentationRender(viewportId);
+                return;
             }
             else {
-                utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
+                const segmentationImageData = segmentationActorInput.actor
+                    .getMapper()
+                    .getInputData();
+                if (segmentationImageData.setDerivedImage) {
+                    segmentationImageData.setDerivedImage(derivedImage);
+                }
+                else {
+                    utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
+                }
             }
-        }
+        };
+        derivedImageIds.forEach(updateSegmentationActor);
         viewport.render();
         if (evt.type === Enums.Events.IMAGE_RENDERED) {
             viewport.element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);

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

@@ -1,7 +1,7 @@
 import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, StackViewport, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { SegmentationRepresentations } from '../../../enums';
-import { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getLabelmapActorEntries } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
     const { representationData } = SegmentationState.getSegmentation(segmentationId);
@@ -68,15 +68,17 @@ function performStackLabelmapUpdate({ viewportIds, segmentationId }) {
             if (viewport instanceof VolumeViewport) {
                 return;
             }
-            const actorEntry = getLabelmapActorEntry(viewportId, segmentationId);
-            if (!actorEntry) {
+            const actorEntries = getLabelmapActorEntries(viewportId, segmentationId);
+            if (!actorEntries?.length) {
                 return;
             }
-            const segImageData = actorEntry.actor.getMapper().getInputData();
-            const currentSegmentationImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
-            const segmentationImage = cache.getImage(currentSegmentationImageId);
-            segImageData.modified();
-            csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);
+            actorEntries.forEach((actorEntry, i) => {
+                const segImageData = actorEntry.actor.getMapper().getInputData();
+                const currentSegmentationImageIds = SegmentationState.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+                const segmentationImage = cache.getImage(currentSegmentationImageIds[i]);
+                segImageData.modified();
+                csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);
+            });
         });
     });
 }

package/dist/esm/stateManagement/segmentation/SegmentationStateManager.d.ts

@@ -5,6 +5,7 @@ export default class SegmentationStateManager {
     private state;
     readonly uid: string;
     private _stackLabelmapImageIdReferenceMap;
+    private _labelmapImageIdReferenceMap;
     constructor(uid?: string);
     getState(): Readonly<SegmentationState>;
     private updateState;
@@ -23,6 +24,7 @@ export default class SegmentationStateManager {
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     getLabelmapImageIds(representationData: RepresentationsData): any;
+    getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[] | undefined;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
     getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
     private removeSegmentationRepresentationsInternal;
@@ -40,6 +42,11 @@ export default class SegmentationStateManager {
         segmentationId: string;
         type: SegmentationRepresentations;
     }>;
+    _updateLabelmapImageIdReferenceMap({ segmentationId, referenceImageId, labelmapImageId, }: {
+        segmentationId: any;
+        referenceImageId: any;
+        labelmapImageId: any;
+    }): void;
     _setActiveSegmentation(state: SegmentationState, viewportId: string, segmentationId: string): void;
     setActiveSegmentation(viewportId: string, segmentationId: string): void;
     getActiveSegmentation(viewportId: string): Segmentation | undefined;
@@ -70,6 +77,7 @@ export default class SegmentationStateManager {
         viewportId: string;
         representations: SegmentationRepresentation[];
     }[];
+    private _generateMapKey;
 }
 declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];

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

@@ -13,6 +13,7 @@ const initialDefaultState = {
 export default class SegmentationStateManager {
     constructor(uid) {
         this._stackLabelmapImageIdReferenceMap = new Map();
+        this._labelmapImageIdReferenceMap = new Map();
         uid ||= csUtils.uuidv4();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
         this.uid = uid;
@@ -32,6 +33,8 @@ export default class SegmentationStateManager {
         return this.state.colorLUT.length;
     }
     resetState() {
+        this._stackLabelmapImageIdReferenceMap.clear();
+        this._labelmapImageIdReferenceMap.clear();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
     }
     getSegmentation(segmentationId) {
@@ -158,7 +161,7 @@ export default class SegmentationStateManager {
         }
     }
     _updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds, updateCallback) {
-        const currentImageId = viewport.getCurrentImageId();
+        const referenceImageId = viewport.getCurrentImageId();
         let viewableLabelmapImageIdFound = false;
         for (const labelmapImageId of labelmapImageIds) {
             const viewableImageId = viewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
@@ -166,7 +169,12 @@ export default class SegmentationStateManager {
                 viewableLabelmapImageIdFound = true;
                 this._stackLabelmapImageIdReferenceMap
                     .get(segmentationId)
-                    .set(currentImageId, labelmapImageId);
+                    .set(referenceImageId, labelmapImageId);
+                this._updateLabelmapImageIdReferenceMap({
+                    segmentationId,
+                    referenceImageId,
+                    labelmapImageId,
+                });
             }
         }
         if (updateCallback) {
@@ -175,7 +183,7 @@ export default class SegmentationStateManager {
         return viewableLabelmapImageIdFound
             ? this._stackLabelmapImageIdReferenceMap
                 .get(segmentationId)
-                .get(currentImageId)
+                .get(referenceImageId)
             : undefined;
     }
     updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
@@ -212,13 +220,18 @@ export default class SegmentationStateManager {
         const stackViewport = enabledElement.viewport;
         this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
             const imageIds = stackViewport.getImageIds();
-            imageIds.forEach((imageId, index) => {
+            imageIds.forEach((referenceImageId, index) => {
                 for (const labelmapImageId of labelmapImageIds) {
                     const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId, sliceIndex: index }, { asOverlay: true, withNavigation: true });
                     if (viewableImageId) {
                         this._stackLabelmapImageIdReferenceMap
                             .get(segmentationId)
-                            .set(imageId, labelmapImageId);
+                            .set(referenceImageId, labelmapImageId);
+                        this._updateLabelmapImageIdReferenceMap({
+                            segmentationId,
+                            referenceImageId,
+                            labelmapImageId,
+                        });
                     }
                 }
             });
@@ -240,6 +253,19 @@ export default class SegmentationStateManager {
         }
         return labelmapImageIds;
     }
+    getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const stackViewport = enabledElement.viewport;
+        const referenceImageId = stackViewport.getCurrentImageId();
+        const key = this._generateMapKey({
+            segmentationId,
+            referenceImageId,
+        });
+        return this._labelmapImageIdReferenceMap.get(key);
+    }
     getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
@@ -330,6 +356,16 @@ export default class SegmentationStateManager {
         }
         return removedRepresentations;
     }
+    _updateLabelmapImageIdReferenceMap({ segmentationId, referenceImageId, labelmapImageId, }) {
+        const key = this._generateMapKey({ segmentationId, referenceImageId });
+        if (!this._labelmapImageIdReferenceMap.has(key)) {
+            this._labelmapImageIdReferenceMap.set(key, [labelmapImageId]);
+            return;
+        }
+        const currentValues = this._labelmapImageIdReferenceMap.get(key);
+        const newValues = Array.from(new Set([...currentValues, labelmapImageId]));
+        this._labelmapImageIdReferenceMap.set(key, newValues);
+    }
     _setActiveSegmentation(state, viewportId, segmentationId) {
         const viewport = state.viewportSegRepresentations[viewportId];
         if (!viewport) {
@@ -435,6 +471,9 @@ export default class SegmentationStateManager {
         });
         return result;
     }
+    _generateMapKey({ segmentationId, referenceImageId }) {
+        return `${segmentationId}-${referenceImageId}`;
+    }
 }
 async function internalComputeVolumeLabelmapFromStack({ imageIds, options, }) {
     const segmentationImageIds = imageIds;

package/dist/esm/stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.d.ts

@@ -1 +1,2 @@
 export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string;
+export declare function getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[];

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

@@ -1,5 +1,9 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
+    const imageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+    return imageIds[0];
+}
+export function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
+    return segmentationStateManager.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
 }

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

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

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

@@ -13,10 +13,26 @@ function getActorEntry(viewportId, segmentationId, filterFn) {
     const filteredActors = actors.filter(filterFn);
     return filteredActors.length > 0 ? filteredActors[0] : undefined;
 }
+function getActorEntries(viewportId, filterFn) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { renderingEngine, viewport } = enabledElement;
+    if (!renderingEngine || !viewport) {
+        return;
+    }
+    const actors = viewport.getActors();
+    const filteredActors = actors.filter(filterFn);
+    return filteredActors.length > 0 ? filteredActors : undefined;
+}
 export function getLabelmapActorUID(viewportId, segmentationId) {
     const actorEntry = getLabelmapActorEntry(viewportId, segmentationId);
     return actorEntry?.uid;
 }
+export function getLabelmapActorEntries(viewportId, segmentationId) {
+    return getActorEntries(viewportId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
+}
 export function getLabelmapActorEntry(viewportId, segmentationId) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
 }

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

@@ -1,3 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-import { getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID } from './getSegmentationActor';
-export { validateSegmentationInput, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };
+import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };

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

@@ -1,3 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-import { getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, } from './getSegmentationActor';
-export { validateSegmentationInput, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };
+import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -9,9 +9,9 @@ import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
 import { getViewportSegmentations } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
-import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
+import { getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
 import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId } from './getSegmentationRepresentation';
 declare function destroy(): void;
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

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

@@ -9,7 +9,7 @@ import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
 import { getViewportSegmentations } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
-import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
+import { getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
 import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId, } from './getSegmentationRepresentation';
@@ -17,4 +17,4 @@ import { defaultSegmentationStateManager } from './SegmentationStateManager';
 function destroy() {
     defaultSegmentationStateManager.resetState();
 }
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

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

@@ -1,5 +1,5 @@
 import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
-import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../enums';
@@ -56,13 +56,11 @@ async function addLabelmapToElement(element, labelMapData, segmentationId, confi
         }
     }
     else {
-        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
-        const stackInputs = [
-            {
-                imageId: segmentationImageId,
-                representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
-            },
-        ];
+        const segmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        const stackInputs = segmentationImageIds.map((imageId) => ({
+            imageId,
+            representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}-${imageId}`,
+        }));
         addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
     }
     triggerSegmentationDataModified(segmentationId);

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

@@ -3,13 +3,13 @@ import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
 import { getActiveSegmentation } from '../../../stateManagement/segmentation/activeSegmentation';
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
-import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 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 { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getLabelmapActorEntries } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 import { getPolySeg } from '../../../config';
 import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
@@ -42,7 +42,7 @@ async function render(viewport, representation) {
         return;
     }
     let labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
-    let labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    let labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
     if (!labelmapData &&
         getPolySeg()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
         !polySegConversionInProgress) {
@@ -66,25 +66,27 @@ async function render(viewport, representation) {
         return;
     }
     if (viewport instanceof VolumeViewport) {
-        if (!labelmapActorEntry) {
+        if (!labelmapActorEntries?.length) {
             await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
-        labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+        labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
     }
     else {
-        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
-        if (!labelmapImageId) {
+        const labelmapImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        if (!labelmapImageIds?.length) {
             return;
         }
-        if (!labelmapActorEntry) {
+        if (!labelmapActorEntries) {
             await _addLabelmapToViewport(viewport, labelmapData, segmentationId, config);
         }
-        labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+        labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId);
     }
-    if (!labelmapActorEntry) {
+    if (!labelmapActorEntries?.length) {
         return;
     }
-    _setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
+    for (const labelmapActorEntry of labelmapActorEntries) {
+        _setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
+    }
 }
 function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentationRepresentation) {
     const { segmentationId } = segmentationRepresentation;

package/dist/esm/utilities/segmentation/getSegmentIndexAtWorldPoint.js

@@ -1,6 +1,6 @@
 import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
-import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getCurrentLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getAnnotation } from '../../stateManagement';
 import { isPointInsidePolyline3D } from '../math/polyline';
 import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
@@ -31,7 +31,12 @@ export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { vi
         const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
         return segmentIndex;
     }
-    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentation.segmentationId);
+    const segmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentation.segmentationId);
+    if (segmentationImageIds.length > 1) {
+        console.warn('Segment selection for labelmaps with multiple imageIds in stack viewports is not supported yet.');
+        return;
+    }
+    const segmentationImageId = segmentationImageIds[0];
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.3.3",
+  "version": "3.4.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.3.3",
+    "@cornerstonejs/core": "^3.4.0",
     "@kitware/vtk.js": "32.9.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "66f7ef454b3e787528c463f05a568d4d19f4cfc2"
+  "gitHead": "822b0c3f30dc9d1d9a5e638f099ce463c689ee14"
 }