@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/UltrasoundPleuraBLineTool.js

@@ -1,3 +1,4 @@
+var _a;
 import { Events, ChangeTypes } from '../../../enums';
 import { getEnabledElement, utilities, metaData, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../../base';
@@ -15,11 +16,6 @@ import { angleFromCenter, calculateInnerFanPercentage, clipInterval, intervalFro
 import { calculateFanGeometry } from './utils/fanExtraction';
 const { transformIndexToWorld } = utilities;
 class UltrasoundPleuraBLineTool extends AnnotationTool {
-    static { this.toolName = 'UltrasoundPleuraBLineTool'; }
-    static { this.USPleuraBLineAnnotationType = {
-        BLINE: 'bLine',
-        PLEURA: 'pleura',
-    }; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -311,7 +307,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
             const currentImageId = viewport.getCurrentImageId();
             const unMergedPleuraIntervals = annotations
                 .filter((annotation) => annotation.data.annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+                _a.USPleuraBLineAnnotationType.PLEURA &&
                 annotation.metadata.referencedImageId === currentImageId)
                 .map((annotation) => {
                 const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
@@ -364,7 +360,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
                     const lineInterval = intervalFromPoints(fanCenter, canvasCoordinates);
                     let fanNumber = 0;
                     if (annotation.data.annotationType ===
-                        UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+                        _a.USPleuraBLineAnnotationType.BLINE) {
                         const uncoveredIntervals = subtractIntervals(bLineIntervalsDisplayed, lineInterval);
                         uncoveredIntervals.forEach((interval) => {
                             const clippedIntervals = clipInterval(interval, mergedPleuraIntervals);
@@ -386,7 +382,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
                         });
                     }
                     else if (annotation.data.annotationType ===
-                        UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+                        _a.USPleuraBLineAnnotationType.PLEURA) {
                         const uncoveredIntervals = subtractIntervals(pleuraIntervalsDisplayed, lineInterval);
                         uncoveredIntervals.forEach((interval, index) => {
                             fanNumber++;
@@ -407,7 +403,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
                 }
             };
             const pleuraAnnotationsToDraw = annotations.filter((annotation) => annotation.data.annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+                _a.USPleuraBLineAnnotationType.PLEURA &&
                 annotation.metadata.referencedImageId === currentImageId);
             pleuraAnnotationsToDraw.forEach((annotation) => {
                 if (!viewport.getRenderingEngine()) {
@@ -417,7 +413,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
                 drawAnnotation(annotation);
             });
             const bLineAnnotationsToDraw = annotations.filter((annotation) => annotation.data.annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE &&
+                _a.USPleuraBLineAnnotationType.BLINE &&
                 annotation.metadata.referencedImageId === currentImageId);
             bLineAnnotationsToDraw.forEach((annotation) => {
                 if (!viewport.getRenderingEngine()) {
@@ -433,10 +429,10 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
             return renderStatus;
         };
         this.activeAnnotationType =
-            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE;
+            _a.USPleuraBLineAnnotationType.BLINE;
     }
     static filterAnnotations(element, filterFunction = () => true) {
-        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        const annotations = getAnnotations(_a.toolName, element);
         if (!annotations?.length) {
             return [];
         }
@@ -447,7 +443,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
         return filteredAnnotations;
     }
     static countAnnotations(element, filterFunction = () => true) {
-        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        const annotations = getAnnotations(_a.toolName, element);
         const { viewport } = getEnabledElement(element);
         const imageIds = viewport.getImageIds();
         const getImageIdIndex = (imageId) => {
@@ -479,11 +475,11 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
                 };
             }
             if (annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+                _a.USPleuraBLineAnnotationType.PLEURA) {
                 counts.pleura++;
             }
             else if (annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+                _a.USPleuraBLineAnnotationType.BLINE) {
                 counts.bLine++;
             }
             annotationMapping.set(currentImageId, counts);
@@ -491,7 +487,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
         return annotationMapping;
     }
     static deleteAnnotations(element, filterFunction = () => false) {
-        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        const annotations = getAnnotations(_a.toolName, element);
         if (!annotations?.length) {
             return;
         }
@@ -510,50 +506,20 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
     }
     deleteLastAnnotationType(element, type) {
         let annotationList;
-        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
-        if (type === UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+        const annotations = getAnnotations(_a.toolName, element);
+        if (type === _a.USPleuraBLineAnnotationType.PLEURA) {
             annotationList = annotations.filter((annotation) => annotation.data.annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA);
+                _a.USPleuraBLineAnnotationType.PLEURA);
         }
-        else if (type === UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+        else if (type === _a.USPleuraBLineAnnotationType.BLINE) {
             annotationList = annotations.filter((annotation) => annotation.data.annotationType ===
-                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE);
+                _a.USPleuraBLineAnnotationType.BLINE);
         }
         if (annotationList?.length > 0) {
             const annotation = annotationList.pop();
             removeAnnotation(annotation.annotationUID);
         }
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(UltrasoundPleuraBLineTool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || utilities.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                },
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
     handleSelectedCallback(evt, annotation, handle) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;
@@ -655,7 +621,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
         const annotations = getAnnotations(this.getToolName(), element) || [];
         const pleuraIntervals = annotations
             .filter((annotation) => annotation.data.annotationType ===
-            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+            _a.USPleuraBLineAnnotationType.PLEURA &&
             annotation.metadata.referencedImageId === currentImageId)
             .map((annotation) => {
             const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
@@ -663,7 +629,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
         });
         const bLineIntervals = annotations
             .filter((annotation) => annotation.data.annotationType ===
-            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE &&
+            _a.USPleuraBLineAnnotationType.BLINE &&
             annotation.metadata.referencedImageId === currentImageId)
             .map((annotation) => {
             const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
@@ -675,11 +641,11 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
         const { annotationType } = annotation.data;
         const { bLineColor, pleuraColor } = this.configuration;
         if (annotationType ===
-            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+            _a.USPleuraBLineAnnotationType.BLINE) {
             return bLineColor;
         }
         if (annotationType ===
-            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+            _a.USPleuraBLineAnnotationType.PLEURA) {
             return pleuraColor;
         }
         return bLineColor;
@@ -746,6 +712,42 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
             utilities.indexWithinDimensions(index2, dimensions));
     }
 }
+_a = UltrasoundPleuraBLineTool;
+UltrasoundPleuraBLineTool.toolName = 'UltrasoundPleuraBLineTool';
+UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType = {
+    BLINE: 'bLine',
+    PLEURA: 'pleura',
+};
+UltrasoundPleuraBLineTool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || utilities.uuidv4(),
+        data: {
+            handles: {
+                points,
+            },
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function defaultGetTextLines(data, targetId) {
     return [''];
 }

package/dist/esm/tools/annotation/VideoRedactionTool.js

@@ -12,7 +12,6 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
 class VideoRedactionTool extends AnnotationTool {
-    static { this.toolName = 'VideoRedaction'; }
     constructor(toolConfiguration = {}) {
         super(toolConfiguration, {
             supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -443,4 +442,5 @@ class VideoRedactionTool extends AnnotationTool {
         return `stackTarget:${viewport.uid}`;
     }
 }
+VideoRedactionTool.toolName = 'VideoRedaction';
 export default VideoRedactionTool;

package/dist/esm/tools/base/AnnotationDisplayTool.js

@@ -3,6 +3,7 @@ import BaseTool from './BaseTool';
 import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
 import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
 import filterAnnotationsForDisplay from '../../utilities/planar/filterAnnotationsForDisplay';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 import { getState } from '../../stateManagement/annotation/config';
 class AnnotationDisplayTool extends BaseTool {
@@ -81,17 +82,19 @@ class AnnotationDisplayTool extends BaseTool {
         const { world: worldPos } = currentPoints;
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
-        const { viewPlaneNormal, viewUp, position: cameraPosition } = camera;
-        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
         const viewReference = viewport.getViewReference({ points: [worldPos] });
+        const { viewPlaneNormal, viewUp, position: cameraPosition, } = getViewportICamera(viewport, viewReference);
+        const referencedImageId = viewReference.referencedImageId ||
+            (viewPlaneNormal
+                ? this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp)
+                : undefined);
         const annotation = AnnotationDisplayTool.createAnnotation({
             metadata: {
                 toolName: this.getToolName(),
                 ...viewReference,
-                referencedImageId,
-                viewUp,
-                cameraPosition,
+                ...(referencedImageId ? { referencedImageId } : {}),
+                ...(viewUp ? { viewUp } : {}),
+                ...(cameraPosition ? { cameraPosition } : {}),
             },
             data: {
                 handles: {

package/dist/esm/tools/base/AnnotationTool.js

@@ -11,6 +11,7 @@ import ChangeTypes from '../../enums/ChangeTypes';
 import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
 import { addContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
 import { safeStructuredClone } from '../../utilities/safeStructuredClone';
+import getViewportICamera from '../../utilities/getViewportICamera';
 const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class AnnotationTool extends AnnotationDisplayTool {
     static createAnnotationForViewport(viewport, ...annotationBaseData) {
@@ -291,7 +292,7 @@ class AnnotationTool extends AnnotationDisplayTool {
         }
         const { viewport } = enabledElement;
         const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const viewPlaneNormal = options.viewplaneNormal ?? camera.viewPlaneNormal;
         const viewUp = options.viewUp ?? camera.viewUp;
         const instance = options.toolInstance || new ToolClass();

package/dist/esm/tools/base/BaseTool.js

@@ -1,18 +1,10 @@
-import { utilities as csUtils } from '@cornerstonejs/core';
+import { utilities as csUtils, viewportHasPan, viewportHasZoom, } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class BaseTool {
     get configurationTyped() {
         return this.configuration;
     }
-    static { this.defaults = {
-        configuration: {
-            strategies: {},
-            defaultStrategy: undefined,
-            activeStrategy: undefined,
-            strategyOptions: {},
-        },
-    }; }
     constructor(toolProps, defaultToolProps) {
         this.isPrimary = false;
         const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
@@ -116,6 +108,9 @@ class BaseTool {
         DefaultHistoryMemo.redo();
     }
     static createZoomPanMemo(viewport) {
+        if (!viewportHasPan(viewport) || !viewportHasZoom(viewport)) {
+            return;
+        }
         const state = {
             pan: viewport.getPan(),
             zoom: viewport.getZoom(),
@@ -124,9 +119,12 @@ class BaseTool {
             restoreMemo: () => {
                 const currentPan = viewport.getPan();
                 const currentZoom = viewport.getZoom();
+                const renderableViewport = viewport;
                 viewport.setZoom(state.zoom);
                 viewport.setPan(state.pan);
-                viewport.render();
+                if (typeof renderableViewport.render === 'function') {
+                    renderableViewport.render();
+                }
                 state.pan = currentPan;
                 state.zoom = currentZoom;
             },
@@ -174,5 +172,13 @@ class BaseTool {
         return true;
     }
 }
+BaseTool.defaults = {
+    configuration: {
+        strategies: {},
+        defaultStrategy: undefined,
+        activeStrategy: undefined,
+        strategyOptions: {},
+    },
+};
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -14,7 +14,6 @@ import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segm
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 import { defaultSegmentationStateManager } from '../../stateManagement/segmentation/SegmentationStateManager';
 class ContourSegmentationBaseTool extends ContourBaseTool {
-    static { this.PreviewSegmentIndex = 255; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
         if (this.configuration.interpolation?.enabled) {
@@ -163,4 +162,5 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         };
     }
 }
+ContourSegmentationBaseTool.PreviewSegmentIndex = 255;
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

package/dist/esm/tools/base/GrowCutBaseTool.js

@@ -10,7 +10,6 @@ import { getOrCreateSegmentationVolume } from '../../utilities/segmentation';
 import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
 class GrowCutBaseTool extends BaseTool {
-    static { this.lastGrowCutCommand = null; }
     constructor(toolProps, defaultToolProps) {
         const baseToolProps = csUtils.deepMerge({
             configuration: {
@@ -209,7 +208,7 @@ class GrowCutBaseTool extends BaseTool {
         const derivedVolume = new ImageVolume({
             volumeId,
             dataType: volumeProps.dataType,
-            metadata: structuredClone(volumeProps.metadata),
+            metadata: csUtils.deepClone(volumeProps.metadata),
             dimensions: volumeProps.dimensions,
             spacing: volumeProps.spacing,
             origin: volumeProps.origin,
@@ -276,5 +275,6 @@ class GrowCutBaseTool extends BaseTool {
         });
     }
 }
+GrowCutBaseTool.lastGrowCutCommand = null;
 GrowCutBaseTool.toolName = 'GrowCutBaseTool';
 export default GrowCutBaseTool;

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

@@ -1,7 +1,5 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
 import type { LabelmapRenderingConfig } from '../../../types/SegmentationStateTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<void | {
-    uid: string;
-    actor: any;
-}>;
+import { type LabelmapRenderPlanMountResult } from './labelmapRenderPlan';
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<LabelmapRenderPlanMountResult>;
 export default addLabelmapToElement;

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

@@ -1,91 +1,21 @@
-import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
-import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getEnabledElement } from '@cornerstonejs/core';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
-import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { SegmentationRepresentations } from '../../../enums';
-import { addVolumesAsIndependentComponents } from './addVolumesAsIndependentComponents';
-const { uuidv4 } = utilities;
+import { resolveLabelmapRenderPlan, } from './labelmapRenderPlan';
 async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
     const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
-    const { id: viewportId } = viewport;
-    const visibility = true;
-    const immediateRender = false;
-    const suppressEvents = true;
-    if (viewport instanceof BaseVolumeViewport) {
-        const volumeLabelMapData = labelMapData;
-        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
-        if (!cache.getVolume(volumeId)) {
-            await _handleMissingVolume(labelMapData);
-        }
-        let blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-        let useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
-        if (useIndependentComponents) {
-            const referenceVolumeId = viewport.getVolumeId();
-            const baseVolume = cache.getVolume(referenceVolumeId);
-            const segVolume = cache.getVolume(volumeId);
-            const segDims = segVolume.dimensions;
-            const refDims = baseVolume.dimensions;
-            if (segDims[0] !== refDims[0] ||
-                segDims[1] !== refDims[1] ||
-                segDims[2] !== refDims[2]) {
-                useIndependentComponents = false;
-                blendMode = Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-                console.debug('Dimensions mismatch - falling back to regular volume addition');
-            }
-        }
-        const volumeInputs = [
-            {
-                volumeId,
-                visibility,
-                representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
-                useIndependentComponents,
-                blendMode,
-            },
-        ];
-        if (!volumeInputs[0].useIndependentComponents) {
-            await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
-        }
-        else {
-            const result = await addVolumesAsIndependentComponents({
-                viewport,
-                volumeInputs,
-                segmentationId,
-            });
-            return result;
-        }
+    const { viewport } = enabledElement;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
     }
-    else {
-        const segmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId);
-        const stackInputs = segmentationImageIds.map((imageId) => ({
-            imageId,
-            representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}-${imageId}`,
-        }));
-        addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
-    }
-    triggerSegmentationDataModified(segmentationId);
-}
-function _ensureVolumeHasVolumeId(labelMapData, segmentationId) {
-    let { volumeId } = labelMapData;
-    if (!volumeId) {
-        volumeId = uuidv4();
-        const segmentation = getSegmentation(segmentationId);
-        segmentation.representationData.Labelmap = {
-            ...segmentation.representationData.Labelmap,
-            volumeId,
-        };
-        labelMapData.volumeId = volumeId;
-        triggerSegmentationModified(segmentationId);
-    }
-    return volumeId;
-}
-async function _handleMissingVolume(labelMapData) {
-    const stackData = labelMapData;
-    const hasImageIds = stackData.imageIds.length > 0;
-    if (!hasImageIds) {
-        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
-    }
-    const volume = await volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId || uuidv4(), stackData.imageIds);
-    return volume;
+    const renderPlan = resolveLabelmapRenderPlan({
+        viewport,
+        segmentation,
+        representation: {
+            segmentationId,
+            config,
+        },
+    });
+    return renderPlan.mount({ labelMapData });
 }
 export default addLabelmapToElement;

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

@@ -0,0 +1,5 @@
+import { type Types } from '@cornerstonejs/core';
+import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+declare const MAX_NUMBER_COLORS = 255;
+declare function setLabelmapColorAndOpacity(viewportId: string, labelmapActorEntry: Types.ActorEntry, segmentationRepresentation: LabelmapRepresentation): void;
+export { MAX_NUMBER_COLORS, setLabelmapColorAndOpacity };