@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/eventListeners/touch/getTouchEventPoints.js

@@ -1,13 +1,20 @@
 import { getEnabledElement } from '@cornerstonejs/core';
 export default function getTouchEventPoints(evt, element) {
     const elementToUse = element || evt.currentTarget;
+    const { viewport } = getEnabledElement(elementToUse) || {};
+    if (!viewport) {
+        return [];
+    }
     const touches = evt.type === 'touchend' ? evt.changedTouches : evt.touches;
-    return Object.keys(touches).map((i) => {
+    return Object.keys(touches)
+        .map((i) => {
         const clientPoint = _clientToPoint(touches[i]);
         const pagePoint = _pageToPoint(touches[i]);
         const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
-        const { viewport } = getEnabledElement(elementToUse);
-        const worldPoint = viewport.canvasToWorld(canvasPoint);
+        const worldPoint = getWorldPoint(viewport, canvasPoint);
+        if (!worldPoint) {
+            return;
+        }
         return {
             page: pagePoint,
             client: clientPoint,
@@ -21,7 +28,8 @@ export default function getTouchEventPoints(evt, element) {
                 rotationAngle: touches[i].rotationAngle,
             },
         };
-    });
+    })
+        .filter(Boolean);
 }
 function _pagePointsToCanvasPoints(element, pagePoint) {
     const rect = element.getBoundingClientRect();
@@ -36,3 +44,18 @@ function _pageToPoint(touch) {
 function _clientToPoint(touch) {
     return [touch.clientX, touch.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/touch/touchStartListener.js

@@ -1,4 +1,4 @@
-import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
+import { getEnabledElement, triggerEvent, utilities, } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
 import { Swipe } from '../../enums/Touch';
 import getTouchEventPoints from './getTouchEventPoints';
@@ -59,8 +59,8 @@ const defaultTapState = {
     tapMaxDistance: 24,
     tapToleranceMs: 300,
 };
-let state = JSON.parse(JSON.stringify(defaultState));
-let tapState = JSON.parse(JSON.stringify(defaultTapState));
+let state = utilities.deepClone(defaultState);
+let tapState = utilities.deepClone(defaultTapState);
 function triggerEventCallback(ele, name, eventDetail) {
     return triggerEvent(ele, name, eventDetail);
 }
@@ -194,7 +194,7 @@ function _onTouchEnd(evt) {
     };
     triggerEventCallback(eventDetail.element, TOUCH_END, eventDetail);
     _checkTouchTap(evt);
-    state = JSON.parse(JSON.stringify(defaultState));
+    state = utilities.deepClone(defaultState);
     document.removeEventListener('touchmove', _onTouchDrag);
     document.removeEventListener('touchend', _onTouchEnd);
 }
@@ -236,7 +236,7 @@ function _checkTouchTap(evt) {
             taps: tapState.taps,
         };
         triggerEventCallback(eventDetail.element, TOUCH_TAP, eventDetail);
-        tapState = JSON.parse(JSON.stringify(defaultTapState));
+        tapState = utilities.deepClone(defaultTapState);
     }, tapState.tapToleranceMs);
 }
 function _checkTouchSwipe(evt, deltaPoints) {
@@ -267,9 +267,22 @@ function _checkTouchSwipe(evt, deltaPoints) {
     }
 }
 function _updateTouchEventsLastPoints(element, lastPoints) {
-    const { viewport } = getEnabledElement(element);
-    return lastPoints.map((lp) => {
-        const world = viewport.canvasToWorld(lp.canvas);
+    const { viewport } = getEnabledElement(element) || {};
+    if (!viewport) {
+        return lastPoints;
+    }
+    return lastPoints
+        .map((lp) => {
+        let world;
+        try {
+            world = viewport.canvasToWorld(lp.canvas);
+        }
+        catch (error) {
+            if (isNoMountedDataError(error)) {
+                return;
+            }
+            throw error;
+        }
         return {
             page: lp.page,
             client: lp.client,
@@ -277,6 +290,11 @@ function _updateTouchEventsLastPoints(element, lastPoints) {
             world,
             touch: lp.touch,
         };
-    });
+    })
+        .filter(Boolean);
+}
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
 }
 export default touchStartListener;

package/dist/esm/eventListeners/wheel/wheelListener.js

@@ -9,6 +9,10 @@ function wheelListener(evt) {
     if (evt.deltaY > -1 && evt.deltaY < 1) {
         return;
     }
+    const points = getMouseEventPoints(evt);
+    if (!points) {
+        return;
+    }
     evt.preventDefault();
     const { spinX, spinY, pixelX, pixelY } = normalizeWheel(evt);
     const direction = spinY < 0 ? -1 : 1;
@@ -27,7 +31,7 @@ function wheelListener(evt) {
             pixelY,
             direction,
         },
-        points: getMouseEventPoints(evt),
+        points,
     };
     triggerEvent(element, Events.MOUSE_WHEEL, eventDetail);
 }

package/dist/esm/init.js

@@ -10,11 +10,13 @@ import { defaultSegmentationStateManager } from './stateManagement/segmentation/
 import segmentationRepresentationModifiedListener from './eventListeners/segmentation/segmentationRepresentationModifiedListener';
 import { setConfig } from './config';
 import segmentationRemovedListener from './eventListeners/segmentation/segmentationRemovedEventListener';
+import { registerBuiltInSegmentationRepresentationDisplays } from './tools/displayTools/registerBuiltInSegmentationRepresentationDisplays';
 let csToolsInitialized = false;
 export function init(defaultConfiguration = {}) {
     if (csToolsInitialized) {
         return;
     }
+    registerBuiltInSegmentationRepresentationDisplays();
     setConfig(defaultConfiguration);
     _addCornerstoneEventListeners();
     _addCornerstoneToolsEventListeners();

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.js

@@ -1,4 +1,7 @@
 import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
+function isUnsafeKey(key) {
+    return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
 class FrameOfReferenceSpecificAnnotationManager {
     constructor(uid) {
         this.getGroupKey = (annotationGroupSelector) => {
@@ -77,6 +80,9 @@ class FrameOfReferenceSpecificAnnotationManager {
             const { metadata } = annotation;
             const { FrameOfReferenceUID, toolName } = metadata;
             groupKey = groupKey || FrameOfReferenceUID;
+            if (isUnsafeKey(groupKey) || isUnsafeKey(toolName)) {
+                return;
+            }
             const annotations = this.annotations;
             let frameOfReferenceSpecificAnnotations = annotations[groupKey];
             if (!frameOfReferenceSpecificAnnotations) {
@@ -146,13 +152,13 @@ class FrameOfReferenceSpecificAnnotationManager {
                     return;
                 }
                 const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
-                return structuredClone(toolSpecificAnnotations);
+                return utilities.deepClone(toolSpecificAnnotations);
             }
             else if (groupKey) {
                 const frameOfReferenceSpecificAnnotations = annotations[groupKey];
-                return structuredClone(frameOfReferenceSpecificAnnotations);
+                return utilities.deepClone(frameOfReferenceSpecificAnnotations);
             }
-            return structuredClone(annotations);
+            return utilities.deepClone(annotations);
         };
         this.restoreAnnotations = (state, groupKey, toolName) => {
             const annotations = this.annotations;
@@ -168,7 +174,7 @@ class FrameOfReferenceSpecificAnnotationManager {
                 annotations[groupKey] = state;
             }
             else {
-                this.annotations = structuredClone(state);
+                this.annotations = utilities.deepClone(state);
             }
         };
         this.getAllAnnotations = () => {

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

@@ -1,21 +1,13 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
-import Representations from '../../enums/SegmentationRepresentations';
 import { getSegmentation } from './getSegmentation';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
-import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
-import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
-import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
 import { addTool } from '../../store/addTool';
 import { state } from '../../store/state';
 import PlanarFreehandContourSegmentationTool from '../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { addDefaultSegmentationListener } from './segmentationEventManager';
-const renderers = {
-    [Representations.Labelmap]: labelmapDisplay,
-    [Representations.Contour]: contourDisplay,
-    [Representations.Surface]: surfaceDisplay,
-};
+import { getSegmentationRepresentationDisplay } from './SegmentationRepresentationDisplayRegistry';
 const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
 class SegmentationRenderingEngine {
     constructor() {
@@ -108,22 +100,33 @@ class SegmentationRenderingEngine {
             if (representation.type === SegmentationRepresentations.Contour) {
                 this._addPlanarFreeHandToolIfAbsent(viewport);
             }
-            const display = renderers[representation.type];
+            const display = getSegmentationRepresentationDisplay(representation.type);
             const segmentation = getSegmentation(representation.segmentationId);
             const existingRepresentation = segmentation.representationData[representation.type] !== undefined;
-            try {
-                display.render(viewport, representation).then(() => {
-                    if (!existingRepresentation) {
-                        addDefaultSegmentationListener(viewport, representation.segmentationId, representation.type);
-                    }
+            if (!display) {
+                console.warn(`No display registered for segmentation representation type ${representation.type}.`);
+                return Promise.resolve({
+                    segmentationId: representation.segmentationId,
+                    type: representation.type,
                 });
             }
-            catch (error) {
+            return display
+                .render(viewport, representation)
+                .then(() => {
+                if (!existingRepresentation) {
+                    addDefaultSegmentationListener(viewport, representation.segmentationId, representation.type);
+                }
+                return {
+                    segmentationId: representation.segmentationId,
+                    type: representation.type,
+                };
+            })
+                .catch((error) => {
                 console.error(error);
-            }
-            return Promise.resolve({
-                segmentationId: representation.segmentationId,
-                type: representation.type,
+                return {
+                    segmentationId: representation.segmentationId,
+                    type: representation.type,
+                };
             });
         });
         Promise.allSettled(segmentationRenderList).then((results) => {

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

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+type SegmentationRepresentationUpdateFunction = (segmentationId: string) => Promise<void>;
+export type SegmentationRepresentationDisplay = {
+    getUpdateFunction: (viewport: Types.IVolumeViewport | Types.IStackViewport) => SegmentationRepresentationUpdateFunction | void | null;
+    render: (viewport: Types.IVolumeViewport | Types.IStackViewport, representation: SegmentationRepresentation) => Promise<void>;
+    removeRepresentation: (viewportId: string, segmentationId: string, renderImmediate?: boolean) => void;
+};
+export declare function registerSegmentationRepresentationDisplay(representationType: SegmentationRepresentations, display: SegmentationRepresentationDisplay): void;
+export declare function getSegmentationRepresentationDisplay(representationType: SegmentationRepresentations): SegmentationRepresentationDisplay | undefined;
+export {};

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

@@ -0,0 +1,7 @@
+const segmentationRepresentationDisplays = new Map();
+export function registerSegmentationRepresentationDisplay(representationType, display) {
+    segmentationRepresentationDisplays.set(representationType, display);
+}
+export function getSegmentationRepresentationDisplay(representationType) {
+    return segmentationRepresentationDisplays.get(representationType);
+}

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

@@ -4,9 +4,7 @@ import type { RenderingConfig, RepresentationsData, Segmentation, SegmentationRe
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
-    private _stackLabelmapImageIdReferenceMap;
-    private _labelmapImageIdReferenceMap;
-    private _labelmapKeysBySegmentationId;
+    private readonly labelmapImageReferenceResolver;
     constructor(uid?: string);
     getState(): Readonly<SegmentationState>;
     private updateState;
@@ -21,9 +19,7 @@ export default class SegmentationStateManager {
     private addDefaultSegmentationRepresentation;
     addLabelmapRepresentation(state: SegmentationState, viewportId: string, segmentationId: string, renderingConfig?: RenderingConfig): void;
     processLabelmapRepresentationAddition(viewportId: string, segmentationId: string): Promise<void>;
-    _updateLabelmapSegmentationReferences(segmentationId: any, viewport: any, labelmapImageIds: any, updateCallback: any): string | undefined;
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
-    _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     getLabelmapImageIds(representationData: RepresentationsData): any;
     getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];
     getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[] | undefined;
@@ -44,11 +40,6 @@ 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;
@@ -79,7 +70,6 @@ export default class SegmentationStateManager {
         viewportId: string;
         representations: SegmentationRepresentation[];
     }[];
-    private _generateMapKey;
 }
 declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];

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

@@ -1,10 +1,12 @@
-import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, volumeLoader, } from '@cornerstonejs/core';
+import { utilities as csUtils, getEnabledElementByViewportId, volumeLoader, } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import getViewportLabelmapRenderMode from './helpers/getViewportLabelmapRenderMode';
 import { triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, } from './triggerSegmentationEvents';
 import { segmentationStyle } from './SegmentationStyle';
 import { triggerSegmentationAdded } from './events/triggerSegmentationAdded';
+import { ensureLabelmapState, LabelmapImageReferenceResolver, syncLegacyLabelmapData, } from './labelmapModel';
 const initialDefaultState = {
     colorLUT: [],
     segmentations: [],
@@ -12,12 +14,10 @@ const initialDefaultState = {
 };
 export default class SegmentationStateManager {
     constructor(uid) {
-        this._stackLabelmapImageIdReferenceMap = new Map();
-        this._labelmapImageIdReferenceMap = new Map();
-        this._labelmapKeysBySegmentationId = new Map();
         uid ||= csUtils.uuidv4();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
         this.uid = uid;
+        this.labelmapImageReferenceResolver = new LabelmapImageReferenceResolver(this.getSegmentation.bind(this));
     }
     getState() {
         return this.state;
@@ -34,9 +34,7 @@ export default class SegmentationStateManager {
         return this.state.colorLUT.length;
     }
     resetState() {
-        this._stackLabelmapImageIdReferenceMap.clear();
-        this._labelmapImageIdReferenceMap.clear();
-        this._labelmapKeysBySegmentationId.clear();
+        this.labelmapImageReferenceResolver.reset();
         this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
     }
     getSegmentation(segmentationId) {
@@ -50,6 +48,10 @@ export default class SegmentationStateManager {
                 return;
             }
             Object.assign(segmentation, payload);
+            if (segmentation.representationData?.Labelmap) {
+                ensureLabelmapState(segmentation);
+                syncLegacyLabelmapData(segmentation);
+            }
         });
         triggerSegmentationModified(segmentationId);
     }
@@ -59,9 +61,12 @@ export default class SegmentationStateManager {
         }
         this.updateState((state) => {
             const newSegmentation = csUtils.deepClone(segmentation);
-            if (newSegmentation.representationData.Labelmap &&
-                'volumeId' in newSegmentation.representationData.Labelmap &&
-                !('imageIds' in newSegmentation.representationData.Labelmap)) {
+            if (newSegmentation.representationData?.Labelmap) {
+                ensureLabelmapState(newSegmentation);
+                syncLegacyLabelmapData(newSegmentation);
+            }
+            const labelmapData = newSegmentation.representationData.Labelmap;
+            if (labelmapData?.volumeId && !('imageIds' in labelmapData)) {
                 const imageIds = this.getLabelmapImageIds(newSegmentation.representationData);
                 newSegmentation.representationData
                     .Labelmap.imageIds = imageIds;
@@ -71,14 +76,7 @@ export default class SegmentationStateManager {
         triggerSegmentationAdded(segmentation.segmentationId);
     }
     removeSegmentation(segmentationId) {
-        this._stackLabelmapImageIdReferenceMap.delete(segmentationId);
-        const keys = this._labelmapKeysBySegmentationId.get(segmentationId);
-        if (keys) {
-            for (const key of keys) {
-                this._labelmapImageIdReferenceMap.delete(key);
-            }
-            this._labelmapKeysBySegmentationId.delete(segmentationId);
-        }
+        this.labelmapImageReferenceResolver.removeSegmentation(segmentationId);
         this.updateState((state) => {
             const filteredSegmentations = state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
             state.segmentations.splice(0, state.segmentations.length, ...filteredSegmentations);
@@ -96,6 +94,7 @@ export default class SegmentationStateManager {
         });
         if (existingRepresentations.length > 0) {
             console.debug('A segmentation representation of type', type, 'already exists in viewport', viewportId, 'for segmentation', segmentationId);
+            triggerSegmentationRepresentationModified(viewportId, segmentationId, type);
             return;
         }
         this.updateState((state) => {
@@ -162,148 +161,30 @@ export default class SegmentationStateManager {
         if (!segmentation) {
             return;
         }
-        const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
+        const volumeViewport = getViewportLabelmapRenderMode(enabledElement.viewport) === 'volume';
         const { representationData } = segmentation;
-        const isBaseVolumeSegmentation = 'volumeId' in representationData.Labelmap;
-        const viewport = enabledElement.viewport;
+        const isBaseVolumeSegmentation = !!representationData.Labelmap.volumeId;
         if (!volumeViewport && !isBaseVolumeSegmentation) {
             !this.updateLabelmapSegmentationImageReferences(viewportId, segmentation.segmentationId);
         }
     }
-    _updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds, updateCallback) {
-        const referenceImageId = viewport.getCurrentImageId();
-        let viewableLabelmapImageIdFound = false;
-        for (const labelmapImageId of labelmapImageIds) {
-            const viewableImageId = viewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
-            if (viewableImageId) {
-                viewableLabelmapImageIdFound = true;
-                this._stackLabelmapImageIdReferenceMap
-                    .get(segmentationId)
-                    .set(referenceImageId, labelmapImageId);
-                this._updateLabelmapImageIdReferenceMap({
-                    segmentationId,
-                    referenceImageId,
-                    labelmapImageId,
-                });
-            }
-        }
-        if (updateCallback) {
-            updateCallback(viewport, segmentationId, labelmapImageIds);
-        }
-        return viewableLabelmapImageIdFound
-            ? this._stackLabelmapImageIdReferenceMap
-                .get(segmentationId)
-                .get(referenceImageId)
-            : undefined;
-    }
     updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
-        const segmentation = this.getSegmentation(segmentationId);
-        if (!segmentation) {
-            return;
-        }
-        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
-            this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
-        }
-        const { representationData } = segmentation;
-        if (!representationData.Labelmap) {
-            return;
-        }
-        const labelmapImageIds = this.getLabelmapImageIds(representationData);
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        const stackViewport = enabledElement.viewport;
-        return this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, null);
-    }
-    _updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId) {
-        const segmentation = this.getSegmentation(segmentationId);
-        if (!segmentation) {
-            return;
-        }
-        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
-            this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
-        }
-        const { representationData } = segmentation;
-        if (!representationData.Labelmap) {
-            return;
-        }
-        const labelmapImageIds = this.getLabelmapImageIds(representationData);
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        const stackViewport = enabledElement.viewport;
-        this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
-            const imageIds = stackViewport.getImageIds();
-            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(referenceImageId, labelmapImageId);
-                        this._updateLabelmapImageIdReferenceMap({
-                            segmentationId,
-                            referenceImageId,
-                            labelmapImageId,
-                        });
-                    }
-                }
-            });
-        });
+        return this.labelmapImageReferenceResolver.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
     }
     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;
+        return this.labelmapImageReferenceResolver.getLabelmapImageIds(representationData);
     }
     getLabelmapImageIdsForImageId(imageId, segmentationId) {
-        const key = this._generateMapKey({
-            segmentationId,
-            referenceImageId: imageId,
-        });
-        return this._labelmapImageIdReferenceMap.get(key);
+        return this.labelmapImageReferenceResolver.getLabelmapImageIdsForImageId(imageId, segmentationId);
     }
     getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const stackViewport = enabledElement.viewport;
-        const referenceImageId = stackViewport.getCurrentImageId();
-        return this.getLabelmapImageIdsForImageId(referenceImageId, segmentationId);
+        return this.labelmapImageReferenceResolver.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
     }
     getCurrentLabelmapImageIdForViewport(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);
+        return this.labelmapImageReferenceResolver.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
     }
     getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
-        const segmentation = this.getSegmentation(segmentationId);
-        if (!segmentation) {
-            return [];
-        }
-        this._updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
-        const { viewport } = getEnabledElementByViewportId(viewportId);
-        const imageIds = viewport.getImageIds();
-        const associatedReferenceImageAndLabelmapImageIds = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
-        return imageIds.map((imageId) => {
-            return associatedReferenceImageAndLabelmapImageIds.get(imageId);
-        });
+        return this.labelmapImageReferenceResolver.getStackSegmentationImageIdsForViewport(viewportId, segmentationId);
     }
     removeSegmentationRepresentationsInternal(viewportId, specifier) {
         const removedRepresentations = [];
@@ -369,23 +250,6 @@ 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]);
-        }
-        else {
-            const currentValues = this._labelmapImageIdReferenceMap.get(key);
-            const newValues = Array.from(new Set([...currentValues, labelmapImageId]));
-            this._labelmapImageIdReferenceMap.set(key, newValues);
-        }
-        let keys = this._labelmapKeysBySegmentationId.get(segmentationId);
-        if (!keys) {
-            keys = new Set();
-            this._labelmapKeysBySegmentationId.set(segmentationId, keys);
-        }
-        keys.add(key);
-    }
     _setActiveSegmentation(state, viewportId, segmentationId) {
         const viewport = state.viewportSegRepresentations[viewportId];
         if (!viewport) {
@@ -444,13 +308,14 @@ export default class SegmentationStateManager {
     }
     setSegmentationRepresentationVisibility(viewportId, specifier, visible) {
         this.updateState((state) => {
-            const viewportRepresentations = this.getSegmentationRepresentations(viewportId, specifier);
+            const viewportRepresentations = state.viewportSegRepresentations[viewportId]?.filter((representation) => representation.segmentationId === specifier.segmentationId &&
+                representation.type === specifier.type);
             if (!viewportRepresentations) {
                 return;
             }
             viewportRepresentations.forEach((representation) => {
                 representation.visible = visible;
-                Object.entries(representation.segments).forEach(([segmentIndex, segment]) => {
+                Object.values(representation.segments).forEach((segment) => {
                     segment.visible = visible;
                 });
             });
@@ -491,9 +356,6 @@ 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/addColorLUT.js

@@ -2,6 +2,8 @@ import { utilities } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+const PREVIEW_COLOR_INDEX = 255;
+const MINIMUM_COLOR_LUT_ENTRIES = PREVIEW_COLOR_INDEX + 1;
 export function addColorLUT(colorLUT, index) {
     const segmentationStateManager = defaultSegmentationStateManager;
     const indexToUse = index ?? getNextColorLUTIndex();
@@ -16,10 +18,14 @@ export function addColorLUT(colorLUT, index) {
         }
         return color;
     });
-    if (colorLUTToUse.length < 255) {
+    if (colorLUTToUse.length < MINIMUM_COLOR_LUT_ENTRIES) {
         const missingColorLUTs = CORNERSTONE_COLOR_LUT.slice(colorLUTToUse.length);
         colorLUTToUse = [...colorLUTToUse, ...missingColorLUTs];
     }
+    while (colorLUTToUse.length < MINIMUM_COLOR_LUT_ENTRIES) {
+        const paletteIndex = ((colorLUTToUse.length - 1) % (CORNERSTONE_COLOR_LUT.length - 1)) + 1;
+        colorLUTToUse.push([...CORNERSTONE_COLOR_LUT[paletteIndex]]);
+    }
     segmentationStateManager.addColorLUT(colorLUTToUse, indexToUse);
     return indexToUse;
 }