@cornerstonejs/tools 2.0.0-beta.19 → 2.0.0-beta.20

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

@@ -3,9 +3,7 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { BaseVolumeViewport, getEnabledElement, Enums, getEnabledElementByIds, cache, utilities, } from '@cornerstonejs/core';
 import Representations from '../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
-import triggerSegmentationRenderForViewports from '../../utilities/segmentation/triggerSegmentationRenderForViewports';
 const enable = function (element) {
     const { viewport } = getEnabledElement(element);
     if (viewport instanceof BaseVolumeViewport) {
@@ -31,89 +29,59 @@ function _imageChangeEventListener(evt) {
     if (!labelmapRepresentations.length) {
         return;
     }
+    const actors = viewport.getActors();
     labelmapRepresentations.forEach((representation) => {
-        const segmentation = SegmentationState.getSegmentation(representation.segmentationId);
-        if (!segmentation || !segmentation.representationData?.LABELMAP) {
-            return;
-        }
-        const labelmapData = segmentation.representationData.LABELMAP;
-        if (isVolumeSegmentation(labelmapData, viewport)) {
-            return;
-        }
-        const { imageIdReferenceMap } = labelmapData;
-        segmentationRepresentations[representation.segmentationRepresentationUID] =
-            {
-                imageIdReferenceMap,
-            };
+        const { segmentationId } = representation;
+        const labelmapImageId = SegmentationState.updateSegmentationImageReferences(viewportId, segmentationId);
     });
-    const representationList = Object.keys(segmentationRepresentations);
-    const currentImageId = viewport.getCurrentImageId();
-    const actors = viewport.getActors();
-    const segmentationFound = actors.find((actor) => {
-        if (!representationList.includes(actor.uid)) {
-            return false;
+    const allLabelmapActors = actors.filter((actor) => labelmapRepresentations.some((representation) => representation.segmentationRepresentationUID === actor.uid));
+    allLabelmapActors.forEach((actor) => {
+        const validActor = labelmapRepresentations.find((representation) => {
+            const derivedImageId = SegmentationState.getLabelmapImageIdsForViewport(viewportId, representation.segmentationId);
+            return derivedImageId === actor.referencedId;
+        });
+        if (!validActor) {
+            viewport.removeActors([actor.uid]);
         }
-        return true;
     });
-    if (!segmentationFound) {
-        if (!perViewportManualTriggers.has(viewportId)) {
-            perViewportManualTriggers.set(viewportId, true);
-            triggerSegmentationRenderForViewports([viewportId]);
+    labelmapRepresentations.forEach((representation) => {
+        const { segmentationId } = representation;
+        const currentImageId = viewport.getCurrentImageId();
+        const derivedImageId = SegmentationState.getLabelmapImageIdsForViewport(viewportId, segmentationId);
+        if (!derivedImageId) {
+            return;
         }
-        return;
-    }
-    actors.forEach((actor) => {
-        if (!representationList.includes(actor.uid)) {
+        const derivedImage = cache.getImage(derivedImageId);
+        if (!derivedImage) {
+            console.warn('No derived image found in the cache for segmentation representation', representation);
             return;
         }
-        const segmentationActor = actor.actor;
-        const { imageIdReferenceMap } = segmentationRepresentations[actor.uid];
-        const derivedImageId = imageIdReferenceMap.get(currentImageId);
-        const segmentationImageData = segmentationActor.getMapper().getInputData();
-        if (!derivedImageId) {
-            if (segmentationImageData.setDerivedImage) {
-                segmentationImageData.setDerivedImage(null);
-                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 scalarArray = vtkDataArray.newInstance({
                 name: 'Pixels',
                 numberOfComponents: 1,
-                values: new Uint8Array(segmentationImageData.getNumberOfPoints()),
+                values: [...derivedImage.getPixelData()],
             });
             const imageData = vtkImageData.newInstance();
+            imageData.setDimensions(dimensions[0], dimensions[1], 1);
+            imageData.setSpacing(spacing);
+            imageData.setDirection(direction);
+            imageData.setOrigin(originToUse);
             imageData.getPointData().setScalars(scalarArray);
-            segmentationActor.getMapper().setInputData(imageData);
-            return;
-        }
-        const derivedImage = cache.getImage(derivedImageId);
-        const { dimensions, spacing, direction } = viewport.getImageDataMetadata(derivedImage);
-        const currentImage = cache.getImage(currentImageId) ||
-            {
-                imageId: currentImageId,
-            };
-        const { origin: currentOrigin } = viewport.getImageDataMetadata(currentImage);
-        const originToUse = currentOrigin;
-        segmentationImageData.setOrigin(originToUse);
-        segmentationImageData.modified();
-        if (segmentationImageData.getDimensions()[0] !== dimensions[0] ||
-            segmentationImageData.getDimensions()[1] !== dimensions[1]) {
-            viewport.removeActors([actor.uid]);
+            imageData.modified();
             viewport.addImages([
                 {
                     imageId: derivedImageId,
-                    actorUID: actor.uid,
+                    actorUID: representation.segmentationRepresentationUID,
                     callback: ({ imageActor }) => {
-                        const scalarArray = vtkDataArray.newInstance({
-                            name: 'Pixels',
-                            numberOfComponents: 1,
-                            values: [...derivedImage.getPixelData()],
-                        });
-                        const imageData = vtkImageData.newInstance();
-                        imageData.setDimensions(dimensions[0], dimensions[1], 1);
-                        imageData.setSpacing(spacing);
-                        imageData.setDirection(direction);
-                        imageData.setOrigin(originToUse);
-                        imageData.getPointData().setScalars(scalarArray);
                         imageActor.getMapper().setInputData(imageData);
                     },
                 },
@@ -121,11 +89,16 @@ function _imageChangeEventListener(evt) {
             triggerSegmentationRender();
             return;
         }
-        if (segmentationImageData.setDerivedImage) {
-            segmentationImageData.setDerivedImage(derivedImage);
-        }
         else {
-            utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
+            const segmentationImageData = segmentationActorInput.actor
+                .getMapper()
+                .getInputData();
+            if (segmentationImageData.setDerivedImage) {
+                segmentationImageData.setDerivedImage(derivedImage);
+            }
+            else {
+                utilities.updateVTKImageDataWithCornerstoneImage(segmentationImageData, derivedImage);
+            }
         }
         viewport.render();
         if (evt.type === Enums.Events.IMAGE_RENDERED) {

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

@@ -2,17 +2,22 @@ import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewpor
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
+    let modifiedSlices = modifiedSlicesToUse;
     const { representationData, type } = SegmentationState.getSegmentation(segmentationId);
     const labelmapRepresentationData = representationData[type];
+    if ('stack' in labelmapRepresentationData &&
+        'volumeId' in labelmapRepresentationData) {
+        modifiedSlices = [];
+    }
     if ('volumeId' in labelmapRepresentationData) {
         performVolumeLabelmapUpdate({
-            modifiedSlicesToUse,
+            modifiedSlicesToUse: modifiedSlices,
             representationData,
             type,
         });
     }
     const viewportIds = SegmentationState.getViewportIdsWithSegmentationId(segmentationId);
-    if ('imageIdReferenceMap' in labelmapRepresentationData) {
+    if ('imageIds' in labelmapRepresentationData) {
         performStackLabelmapUpdate({
             viewportIds,
             segmentationId,
@@ -29,7 +34,7 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
     }
     const { imageData, vtkOpenGLTexture } = segmentationVolume;
     let slicesToUpdate;
-    if (modifiedSlicesToUse && Array.isArray(modifiedSlicesToUse)) {
+    if (modifiedSlicesToUse?.length > 0) {
         slicesToUpdate = modifiedSlicesToUse;
     }
     else {
@@ -60,10 +65,8 @@ function performStackLabelmapUpdate({ viewportIds, segmentationId, representatio
             if (!actorEntry) {
                 return;
             }
-            const currentImageId = viewport.getCurrentImageId();
             const segImageData = actorEntry.actor.getMapper().getInputData();
-            const { imageIdReferenceMap } = representationData[type];
-            const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+            const currentSegmentationImageId = SegmentationState.getLabelmapImageIdsForViewport(viewportId, representation.segmentationId);
             const segmentationImage = cache.getImage(currentSegmentationImageId);
             segImageData.modified();
             csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);

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

@@ -3,6 +3,7 @@ import type { RepresentationConfig, SegmentRepresentationConfig, Segmentation, S
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
+    private _stackLabelmapImageIdReferenceMap;
     constructor(uid?: string);
     getState(): SegmentationState;
     getColorLUT(lutIndex: number): Types.ColorLUT | undefined;
@@ -14,6 +15,9 @@ export default class SegmentationStateManager {
     getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
     addRepresentation(segmentationRepresentation: SegmentationRepresentation): void;
     addRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    updateSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    private getLabelmapImageIds;
+    getLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string | undefined;
     getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[];
     removeRepresentation(segmentationRepresentationUID: string): void;
     setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
@@ -32,6 +36,7 @@ export default class SegmentationStateManager {
     setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
+    _getStackIdForImageIds(imageIds: string[]): string;
 }
 declare const defaultSegmentationStateManager: SegmentationStateManager;
 export { defaultSegmentationStateManager };

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

@@ -1,8 +1,9 @@
-import { utilities as csUtils } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
 import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
 import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
 import getDefaultSurfaceConfig from '../../tools/displayTools/Surface/surfaceConfig';
+import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 const newGlobalConfig = {
     renderInactiveRepresentations: true,
     representations: {
@@ -20,6 +21,7 @@ const initialDefaultState = {
 };
 export default class SegmentationStateManager {
     constructor(uid) {
+        this._stackLabelmapImageIdReferenceMap = new Map();
         if (!uid) {
             uid = csUtils.uuidv4();
         }
@@ -45,6 +47,13 @@ export default class SegmentationStateManager {
         if (this.getSegmentation(segmentation.segmentationId)) {
             throw new Error(`Segmentation with id ${segmentation.segmentationId} already exists`);
         }
+        if (segmentation.representationData.LABELMAP &&
+            'volumeId' in segmentation.representationData.LABELMAP &&
+            !('imageIds' in segmentation.representationData.LABELMAP)) {
+            const imageIds = this.getLabelmapImageIds(segmentation.representationData);
+            segmentation.representationData
+                .LABELMAP.imageIds = imageIds;
+        }
         this.state.segmentations.push(segmentation);
     }
     removeSegmentation(segmentationId) {
@@ -59,11 +68,98 @@ export default class SegmentationStateManager {
             segmentationRepresentation;
     }
     addRepresentationToViewport(viewportId, segmentationRepresentationUID) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
         if (!this.state.viewports[viewportId]) {
             this.state.viewports[viewportId] = {};
         }
+        const representation = this.getRepresentation(segmentationRepresentationUID);
+        if (representation.type !== SegmentationRepresentations.Labelmap) {
+            this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+            return;
+        }
+        const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
+        const segmentation = this.getSegmentation(representation.segmentationId);
+        const { representationData } = segmentation;
+        const isBaseVolumeSegmentation = 'volumeId' in representationData.LABELMAP;
+        if (!volumeViewport) {
+            if (isBaseVolumeSegmentation) {
+            }
+            else {
+                this.updateSegmentationImageReferences(viewportId, segmentation.segmentationId);
+            }
+        }
+        else {
+            const volumeViewport = enabledElement.viewport;
+            const frameOfReferenceUID = volumeViewport.getFrameOfReferenceUID();
+            if (!isBaseVolumeSegmentation) {
+                const imageIds = this.getLabelmapImageIds(segmentation.representationData);
+                const segImage = cache.getImage(imageIds[0]);
+                if (segImage?.FrameOfReferenceUID === frameOfReferenceUID) {
+                    convertStackToVolumeSegmentation(segmentation);
+                }
+            }
+            else {
+            }
+        }
         this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
     }
+    updateSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        const stackViewport = enabledElement.viewport;
+        const currentImageId = stackViewport.getCurrentImageId();
+        for (const labelmapImageId of labelmapImageIds) {
+            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            if (viewableImageId) {
+                this._stackLabelmapImageIdReferenceMap
+                    .get(segmentationId)
+                    .set(currentImageId, labelmapImageId);
+            }
+        }
+        return this._stackLabelmapImageIdReferenceMap
+            .get(segmentationId)
+            .get(currentImageId);
+    }
+    getLabelmapImageIds(representationData) {
+        const labelmapData = representationData.LABELMAP;
+        let labelmapImageIds;
+        if (labelmapData.imageIds) {
+            labelmapImageIds = labelmapData
+                .imageIds;
+        }
+        else if (!labelmapImageIds &&
+            labelmapData.volumeId) {
+            const volumeId = labelmapData
+                .volumeId;
+            const volume = cache.getVolume(volumeId);
+            labelmapImageIds = volume.imageIds;
+        }
+        return labelmapImageIds;
+    }
+    getLabelmapImageIdsForViewport(viewportId, segmentationId) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            return;
+        }
+        const stackViewport = enabledElement.viewport;
+        const currentImageId = stackViewport.getCurrentImageId();
+        const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
+        return imageIdReferenceMap.get(currentImageId);
+    }
     getRepresentationsForViewport(viewportId) {
         const viewport = this.state.viewports[viewportId];
         if (!viewport) {
@@ -167,6 +263,11 @@ export default class SegmentationStateManager {
     removeColorLUT(colorLUTIndex) {
         delete this.state.colorLUT[colorLUTIndex];
     }
+    _getStackIdForImageIds(imageIds) {
+        return imageIds
+            .map((imageId) => imageId.slice(-Math.round(imageId.length * 0.15)))
+            .join('_');
+    }
 }
 const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
 export { defaultSegmentationStateManager };

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js

@@ -2,7 +2,6 @@ import * as SegmentationState from '../../../stateManagement/segmentation/segmen
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
     const representation = SegmentationState.getRepresentation(segmentationRepresentationUID);
-    debugger;
     if (!representation) {
         return;
     }
@@ -23,7 +22,6 @@ function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentI
 }
 function setSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex, visibility) {
     const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
-    debugger;
     visibility
         ? hiddenSegments.delete(segmentIndex)
         : hiddenSegments.add(segmentIndex);

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

@@ -1,5 +1,5 @@
-declare function computeVolumeSegmentationFromStack({ imageIdReferenceMap, options, }: {
-    imageIdReferenceMap: Map<string, string>;
+declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+    imageIds: string[];
     options?: {
         volumeId?: string;
     };

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

@@ -1,13 +1,12 @@
 import { volumeLoader, utilities as csUtils, eventTarget, cache, } from '@cornerstonejs/core';
-import { Events, SegmentationRepresentations } from '../../enums';
-import addRepresentations from './addRepresentations';
+import { Events } from '../../enums';
 import { triggerSegmentationRender } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
-async function computeVolumeSegmentationFromStack({ imageIdReferenceMap, options, }) {
-    const segmentationImageIds = Array.from(imageIdReferenceMap.values());
+async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
+    const segmentationImageIds = imageIds;
     const additionalDetails = {
-        imageIdReferenceMap,
+        imageIds,
     };
     const volumeId = options?.volumeId ?? csUtils.uuidv4();
     await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds, {
@@ -20,7 +19,7 @@ async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
     const data = segmentation.representationData
         .LABELMAP;
     const { volumeId } = await computeVolumeSegmentationFromStack({
-        imageIdReferenceMap: data.imageIdReferenceMap,
+        imageIds: data.imageIds,
         options,
     });
     await updateSegmentationState({
@@ -35,8 +34,8 @@ async function updateSegmentationState({ segmentationId, viewportId, volumeId, o
     if (options?.removeOriginal) {
         const data = segmentation.representationData
             .LABELMAP;
-        const imageIdReferenceMap = data.imageIdReferenceMap;
-        Array.from(imageIdReferenceMap.values()).forEach((imageId) => {
+        const { imageIds } = data;
+        imageIds.forEach((imageId) => {
             cache.removeImageLoadObject(imageId);
         });
         segmentation.representationData.LABELMAP = {
@@ -49,12 +48,6 @@ async function updateSegmentationState({ segmentationId, viewportId, volumeId, o
             volumeId,
         };
     }
-    await addRepresentations(viewportId, [
-        {
-            segmentationId,
-            type: SegmentationRepresentations.Labelmap,
-        },
-    ]);
     triggerSegmentationRender(viewportId);
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }

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

@@ -1,7 +1,7 @@
 export declare function computeStackSegmentationFromVolume({ volumeId, }: {
     volumeId: string;
 }): Promise<{
-    imageIdReferenceMap: Map<string, string>;
+    imageIds: string[];
 }>;
 export declare function convertVolumeToStackSegmentation({ segmentationId, options, }: {
     segmentationId: string;
@@ -11,10 +11,10 @@ export declare function convertVolumeToStackSegmentation({ segmentationId, optio
         removeOriginal?: boolean;
     };
 }): Promise<void>;
-export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIdReferenceMap, options, }: {
+export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
     segmentationId: string;
     viewportId: string;
-    imageIdReferenceMap: Map<any, any>;
+    imageIds: string[];
     options?: {
         removeOriginal?: boolean;
     };

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

@@ -1,7 +1,7 @@
 import { cache, eventTarget, getRenderingEngines, } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
 import addRepresentations from './addRepresentations';
-import { triggerSegmentationRender, createImageIdReferenceMap, } from '../../utilities/segmentation';
+import { triggerSegmentationRender } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
 export async function computeStackSegmentationFromVolume({ volumeId, }) {
@@ -16,24 +16,24 @@ export async function computeStackSegmentationFromVolume({ volumeId, }) {
         .getVolumeViewports()
         .find((vp) => vp.hasVolumeId(volumeId));
     segmentationVolume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-    const imageIdReferenceMap = _getImageIdReferenceMapForStackSegmentation(segmentationVolume);
-    return { imageIdReferenceMap };
+    const imageIds = _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume);
+    return { imageIds };
 }
 export async function convertVolumeToStackSegmentation({ segmentationId, options, }) {
     const segmentation = getSegmentation(segmentationId);
     const data = segmentation.representationData
         .LABELMAP;
-    const { imageIdReferenceMap } = await computeStackSegmentationFromVolume({
+    const { imageIds } = await computeStackSegmentationFromVolume({
         volumeId: data.volumeId,
     });
     await updateStackSegmentationState({
         segmentationId,
         viewportId: options.viewportId,
-        imageIdReferenceMap,
+        imageIds,
         options,
     });
 }
-export async function updateStackSegmentationState({ segmentationId, viewportId, imageIdReferenceMap, options, }) {
+export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
     const segmentation = getSegmentation(segmentationId);
     if (options?.removeOriginal) {
         const data = segmentation.representationData
@@ -42,13 +42,13 @@ export async function updateStackSegmentationState({ segmentationId, viewportId,
             cache.removeVolumeLoadObject(data.volumeId);
         }
         segmentation.representationData.LABELMAP = {
-            imageIdReferenceMap,
+            imageIds,
         };
     }
     else {
         segmentation.representationData.LABELMAP = {
             ...segmentation.representationData.LABELMAP,
-            imageIdReferenceMap,
+            imageIds,
         };
     }
     await addRepresentations(viewportId, [
@@ -60,15 +60,14 @@ export async function updateStackSegmentationState({ segmentationId, viewportId,
     triggerSegmentationRender();
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
-function _getImageIdReferenceMapForStackSegmentation(segmentationVolume) {
-    if (segmentationVolume.additionalDetails?.imageIdReferenceMap) {
-        return segmentationVolume.additionalDetails.imageIdReferenceMap;
+function _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume) {
+    if (segmentationVolume.additionalDetails?.imageIds) {
+        return segmentationVolume.additionalDetails.imageIds;
     }
     else if (segmentationVolume.referencedImageIds?.length &&
         !segmentationVolume.referencedImageIds[0].startsWith('derived')) {
-        const referencedImageIds = segmentationVolume.referencedImageIds;
         const segmentationImageIds = segmentationVolume.imageIds;
-        return createImageIdReferenceMap(referencedImageIds, [...segmentationImageIds].reverse());
+        return [...segmentationImageIds].reverse();
     }
     else {
         const referencedVolumeId = segmentationVolume.referencedVolumeId;
@@ -81,7 +80,7 @@ function _getImageIdReferenceMapForStackSegmentation(segmentationVolume) {
         }
         if (referencedVolume.imageIds?.[0].startsWith('derived')) {
             throw new Error(`Cannot convert volume segmentation that is derived from another segmentation
-         to stack segmentation yet, include the additionalDetails.imageIdReferenceMap
+         to stack segmentation yet, include the additionalDetails.imageIds
          in the volume segmentation in case you need it for the conversion`);
         }
         const referencedImageIds = referencedVolume.imageIds;
@@ -90,6 +89,6 @@ function _getImageIdReferenceMapForStackSegmentation(segmentationVolume) {
             segmentationImageIdsToUse =
                 segmentationVolume.convertToImageSlicesAndCache();
         }
-        return createImageIdReferenceMap(referencedImageIds, [...segmentationImageIdsToUse].reverse());
+        return [...segmentationImageIdsToUse].reverse();
     }
 }

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.d.ts

@@ -3,5 +3,5 @@ export declare function convertContourToVolumeLabelmap(contourRepresentationData
     volumeId: string;
 }>;
 export declare function convertContourToStackLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
-    imageIdReferenceMap: Map<any, any>;
+    imageIds: any[];
 }>;

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.js

@@ -110,17 +110,17 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
         ],
     });
     triggerWorkerProgress(eventTarget, 1);
-    const imageIdReferenceMap = new Map();
+    const segImageIds = [];
     newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
         const segmentationInfo = segmentationsInfo.get(referencedImageId);
         const { imageId: segImageId } = segmentationInfo;
         const segImage = cache.getImage(segImageId);
         segImage.getPixelData().set(scalarData);
         segImage.imageFrame?.pixelData?.set(scalarData);
-        imageIdReferenceMap.set(referencedImageId, segImageId);
+        segImageIds.push(segImageId);
     });
     return {
-        imageIdReferenceMap,
+        imageIds: segImageIds,
     };
 }
 function _getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.js

@@ -16,9 +16,9 @@ export async function convertLabelmapToSurface(labelmapRepresentationData, segme
             .volumeId;
     }
     else {
-        const { imageIdReferenceMap } = labelmapRepresentationData;
+        const { imageIds } = labelmapRepresentationData;
         ({ volumeId } = await computeVolumeSegmentationFromStack({
-            imageIdReferenceMap,
+            imageIds,
         }));
     }
     const volume = cache.getVolume(volumeId);

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

@@ -33,4 +33,6 @@ declare function getRepresentationVisibility(viewportId: string, segmentationRep
 declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
 declare function getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
 declare function setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, };
+declare function getLabelmapImageIdsForViewport(viewportId: string, segmentationId?: string): string;
+declare function updateSegmentationImageReferences(viewportId: string, segmentationId: string): void;
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };

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

@@ -146,4 +146,12 @@ function setActiveRepresentation(viewportId, segmentationRepresentationUID, supp
         triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, };
+function getLabelmapImageIdsForViewport(viewportId, segmentationId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    return segmentationStateManager.getLabelmapImageIdsForViewport(viewportId, segmentationId);
+}
+function updateSegmentationImageReferences(viewportId, segmentationId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    segmentationStateManager.updateSegmentationImageReferences(viewportId, segmentationId);
+}
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };

package/dist/esm/store/ToolGroupManager/ToolGroup.d.ts

@@ -38,6 +38,8 @@ export default class ToolGroup implements IToolGroup {
     getDefaultPrimaryBindings(): IToolBinding[];
     getToolConfiguration(toolName: string, configurationPath?: string): any;
     getPrevActivePrimaryToolName(): string;
+    setActivePrimaryTool(toolName: string): void;
+    getCurrentActivePrimaryToolName(): string;
     clone(newToolGroupId: any, fnToolFilter?: (toolName: string) => void): IToolGroup;
     private _hasMousePrimaryButtonBinding;
     private _renderViewports;