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

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

@@ -0,0 +1,112 @@
+import { getEnabledElement, triggerEvent, getRenderingEngine, } from '@cornerstonejs/core';
+import { Events, ToolModes } from '../../enums';
+import { draw as drawSvg } from '../../drawingSvg';
+import getToolsWithModesForElement from '../../utilities/getToolsWithModesForElement';
+const { Active, Passive, Enabled } = ToolModes;
+class AnnotationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._renderFlaggedViewports = () => {
+            this._throwIfDestroyed();
+            const elements = Array.from(this._viewportElements.values());
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                if (this._needsRender.has(element)) {
+                    this._triggerRender(element);
+                    this._needsRender.delete(element);
+                    if (this._needsRender.size === 0) {
+                        break;
+                    }
+                }
+            }
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+            this._render();
+        };
+        this._viewportElements = new Map();
+    }
+    addViewportElement(viewportId, element) {
+        this._viewportElements.set(viewportId, element);
+    }
+    removeViewportElement(viewportId, element) {
+        this._viewportElements.delete(viewportId);
+        this._needsRender.delete(element);
+        this._reset();
+    }
+    renderViewport(element) {
+        this._setViewportsToBeRenderedNextFrame([element]);
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setAllViewportsToBeRenderedNextFrame() {
+        const elements = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            this._needsRender.add(element);
+        });
+        this._renderFlaggedViewports();
+    }
+    _setViewportsToBeRenderedNextFrame(elements) {
+        const elementsEnabled = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            if (elementsEnabled.indexOf(element) !== -1) {
+                this._needsRender.add(element);
+            }
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(element) {
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
+        if (!renderingEngine) {
+            console.warn('rendering Engine has been destroyed');
+            return;
+        }
+        const enabledTools = getToolsWithModesForElement(element, [
+            Active,
+            Passive,
+            Enabled,
+        ]);
+        const { renderingEngineId, viewportId } = enabledElement;
+        const eventDetail = {
+            element,
+            renderingEngineId,
+            viewportId,
+        };
+        drawSvg(element, (svgDrawingHelper) => {
+            let anyRendered = false;
+            const handleDrawSvg = (tool) => {
+                if (tool.renderAnnotation) {
+                    const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
+                    anyRendered = anyRendered || rendered;
+                }
+            };
+            enabledTools.forEach(handleDrawSvg);
+            if (anyRendered) {
+                triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
+            }
+        });
+    }
+    _reset() {
+        window.cancelAnimationFrame(this._animationFrameHandle);
+        this._needsRender.clear();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._setAllViewportsToBeRenderedNextFrame();
+    }
+}
+const annotationRenderingEngine = new AnnotationRenderingEngine();
+export { annotationRenderingEngine };

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.d.ts

@@ -1,6 +1,6 @@
-import { Annotation, Annotations, AnnotationState, GroupSpecificAnnotations } from '../../types/AnnotationTypes';
-import { AnnotationGroupSelector, IAnnotationManager } from '../../types';
-import { Types } from '@cornerstonejs/core';
+import type { Annotation, Annotations, AnnotationState, GroupSpecificAnnotations } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector, IAnnotationManager } from '../../types';
+import type { Types } from '@cornerstonejs/core';
 declare class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     private annotations;
     readonly uid: string;

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

@@ -1,6 +1,5 @@
 import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
 import { checkAndDefineIsLockedProperty } from './annotationLocking';
-import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 import { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty, } from './utilities/defineProperties';
 class FrameOfReferenceSpecificAnnotationManager {
     constructor(uid) {
@@ -93,7 +92,6 @@ class FrameOfReferenceSpecificAnnotationManager {
             }
             toolSpecificAnnotations.push(annotation);
             checkAndDefineIsLockedProperty(annotation);
-            checkAndDefineIsVisibleProperty(annotation);
             checkAndDefineTextBoxProperty(annotation);
             checkAndDefineCachedStatsProperty(annotation);
         };

package/dist/esm/stateManagement/annotation/annotationLocking.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationLocked(annotation: Annotation, locked?: boolean): void;
 declare function unlockAllAnnotations(): void;
 declare function getAnnotationsLocked(): Array<Annotation>;

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

@@ -1,6 +1,6 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getAnnotation } from './annotationState';
+import { getAnnotation } from './getAnnotation';
 const selectedAnnotationUIDs = new Set();
 function setAnnotationSelected(annotationUID, selected = true, preserveSelected = false) {
     if (selected) {

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -1,5 +1,6 @@
-import { Annotations, Annotation } from '../../types/AnnotationTypes';
-import { AnnotationGroupSelector } from '../../types';
+import type { Annotations, Annotation } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector } from '../../types';
+import { getAnnotation } from './getAnnotation';
 declare function getAnnotationManager(): import("./FrameOfReferenceSpecificAnnotationManager").default;
 declare function setAnnotationManager(annotationManager: any): void;
 declare function resetAnnotationManager(): void;
@@ -12,8 +13,7 @@ declare function getChildAnnotations(annotation: Annotation): Annotation[];
 declare function addAnnotation(annotation: Annotation, annotationGroupSelector: AnnotationGroupSelector): string;
 declare function getNumberOfAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): number;
 declare function removeAnnotation(annotationUID: string): void;
-declare function getAnnotation(annotationUID: string): Annotation;
 declare function removeAllAnnotations(): void;
 declare function removeAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): void;
 declare function invalidateAnnotation(annotation: Annotation): void;
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

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

@@ -1,6 +1,8 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+import { getAnnotation } from './getAnnotation';
 import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
+import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 let defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
 function getAnnotationManager() {
     return defaultManager;
@@ -55,6 +57,7 @@ function addAnnotation(annotation, annotationGroupSelector) {
     if (!annotation.annotationUID) {
         annotation.annotationUID = csUtils.uuidv4();
     }
+    checkAndDefineIsVisibleProperty(annotation);
     const manager = getAnnotationManager();
     if (annotationGroupSelector instanceof HTMLDivElement) {
         const groupKey = manager.getGroupKey(annotationGroupSelector);
@@ -85,11 +88,6 @@ function removeAnnotation(annotationUID) {
     manager.removeAnnotation(annotationUID);
     triggerAnnotationRemoved({ annotation, annotationManagerUID: manager.uid });
 }
-function getAnnotation(annotationUID) {
-    const manager = getAnnotationManager();
-    const annotation = manager.getAnnotation(annotationUID);
-    return annotation;
-}
 function removeAllAnnotations() {
     const manager = getAnnotationManager();
     const removedAnnotations = manager.removeAllAnnotations();
@@ -120,4 +118,4 @@ function invalidateAnnotation(annotation) {
             : undefined;
     }
 }
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationVisibility.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../types';
+import type { Annotation } from '../../types';
 declare function setAnnotationVisibility(annotationUID: string, visible?: boolean): void;
 declare function showAllAnnotations(): void;
 declare function isAnnotationVisible(annotationUID: string): boolean | undefined;

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

@@ -1,7 +1,7 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
-import { getAnnotation } from './annotationState';
 import { Events } from '../../enums';
 import { isAnnotationSelected, deselectAnnotation, } from './annotationSelection';
+import { getAnnotation } from './getAnnotation';
 const globalHiddenAnnotationUIDsSet = new Set();
 function setAnnotationVisibility(annotationUID, visible = true) {
     const detail = makeEventDetail();

package/dist/esm/stateManagement/annotation/config/ToolStyle.d.ts

@@ -1,4 +1,4 @@
-import { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
+import type { StyleConfig, ToolStyleConfig, StyleSpecifier, AnnotationStyle } from '../../../types/AnnotationStyle';
 declare class ToolStyle {
     config: StyleConfig;
     constructor();

package/dist/esm/stateManagement/annotation/config/getFont.d.ts

@@ -1,4 +1,4 @@
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
 declare function getFont(styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export default getFont;

package/dist/esm/stateManagement/annotation/config/getState.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../../types';
+import type { Annotation } from '../../../types';
 import { AnnotationStyleStates } from '../../../enums';
 declare function getState(annotation?: Annotation): AnnotationStyleStates;
 export default getState;

package/dist/esm/stateManagement/annotation/config/helpers.d.ts

@@ -1,4 +1,4 @@
-import { StyleSpecifier } from '../../../types/AnnotationStyle';
-import { ToolModes, AnnotationStyleStates } from '../../../enums';
+import type { StyleSpecifier } from '../../../types/AnnotationStyle';
+import type { ToolModes, AnnotationStyleStates } from '../../../enums';
 declare function getStyleProperty(property: string, styleSpecifier: StyleSpecifier, state?: AnnotationStyleStates, mode?: ToolModes): string;
 export { getStyleProperty };

package/dist/esm/stateManagement/annotation/getAnnotation.d.ts

@@ -0,0 +1,2 @@
+import type { Annotation } from '../../types';
+export declare function getAnnotation(annotationUID: string): Annotation;

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

@@ -0,0 +1,6 @@
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+export function getAnnotation(annotationUID) {
+    const manager = defaultFrameOfReferenceSpecificAnnotationManager;
+    const annotation = manager.getAnnotation(annotationUID);
+    return annotation;
+}

package/dist/esm/stateManagement/annotation/helpers/state.d.ts

@@ -1,6 +1,6 @@
 import { ChangeTypes } from '../../../enums';
-import { Annotation } from '../../../types/AnnotationTypes';
-import { AnnotationRemovedEventDetail } from '../../../types/EventTypes';
+import type { Annotation } from '../../../types/AnnotationTypes';
+import type { AnnotationRemovedEventDetail } from '../../../types/EventTypes';
 declare function triggerAnnotationAddedForElement(annotation: Annotation, element: HTMLDivElement): void;
 declare function triggerAnnotationAddedForFOR(annotation: Annotation): void;
 declare function triggerAnnotationRemoved(eventDetail: AnnotationRemovedEventDetail): void;

package/dist/esm/stateManagement/annotation/utilities/defineProperties.d.ts

@@ -1,4 +1,4 @@
-import { Annotation } from '../../../types';
+import type { Annotation } from '../../../types';
 declare const checkAndDefineTextBoxProperty: (annotation: Annotation) => Annotation;
 declare const checkAndDefineCachedStatsProperty: (annotation: Annotation) => Annotation;
 export { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty };

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

@@ -15,6 +15,4 @@ import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
 import { resetAnnotationManager } from './annotation/annotationState';
 import { invalidateAnnotation } from './annotation/annotationState';
-import { addRepresentations } from './segmentation';
-import { removeRepresentationsFromViewport } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addRepresentations, removeRepresentationsFromViewport };
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations };

package/dist/esm/stateManagement/index.js

@@ -2,5 +2,6 @@ import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpeci
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
 import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
-import { addRepresentations, removeRepresentationsFromViewport, } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addRepresentations, removeRepresentationsFromViewport, };
+import { addSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
+import { removeSegmentationRepresentations } from './segmentation/removeSegmentationRepresentations';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations, };

package/dist/esm/{tools/displayTools → stateManagement/segmentation}/SegmentationRenderingEngine.d.ts

@@ -1,11 +1,11 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare class SegmentationRenderingEngine {
     private _needsRender;
     private _animationFrameSet;
     private _animationFrameHandle;
     hasBeenDestroyed: boolean;
-    renderSegmentations(segmentationId?: string): void;
-    renderSegmentationsForViewports(viewportIds?: string[]): void;
+    renderSegmentationsForViewport(viewportId?: string): void;
+    renderSegmentation(segmentationId: string): void;
     _getAllViewports: () => Types.IViewport[];
     _getViewportIdsForSegmentation(segmentationId?: string): string[];
     private _throwIfDestroyed;
@@ -15,5 +15,7 @@ declare class SegmentationRenderingEngine {
     _triggerRender(viewportId?: string): void;
     _addPlanarFreeHandToolIfAbsent(viewport: any): void;
 }
+declare function triggerSegmentationRender(viewportId?: string): void;
+declare function triggerSegmentationRenderBySegmentationId(segmentationId?: string): void;
 declare const segmentationRenderingEngine: SegmentationRenderingEngine;
-export { segmentationRenderingEngine };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

package/dist/esm/{tools/displayTools → stateManagement/segmentation}/SegmentationRenderingEngine.js

@@ -1,12 +1,13 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
-import { getRepresentationsForViewport } from '../../stateManagement/segmentation/segmentationState';
-import { surfaceDisplay } from './Surface';
-import { contourDisplay } from './Contour';
-import { labelmapDisplay } from './Labelmap';
-import { addTool, state } from '../../store';
-import PlanarFreehandContourSegmentationTool from '../annotation/PlanarFreehandContourSegmentationTool';
+import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+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';
 const renderers = {
     [Representations.Labelmap]: labelmapDisplay,
@@ -34,25 +35,22 @@ class SegmentationRenderingEngine {
             this._animationFrameHandle = null;
         };
     }
-    renderSegmentations(segmentationId) {
-        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+    renderSegmentationsForViewport(viewportId) {
+        const viewportIds = viewportId
+            ? [viewportId]
+            : this._getViewportIdsForSegmentation();
         this._setViewportsToBeRenderedNextFrame(viewportIds);
     }
-    renderSegmentationsForViewports(viewportIds) {
-        if (!viewportIds?.length) {
-            const allViewports = this._getAllViewports();
-            this._setViewportsToBeRenderedNextFrame(allViewports.map((viewport) => viewport.id));
-        }
-        else {
-            this._setViewportsToBeRenderedNextFrame(viewportIds);
-        }
+    renderSegmentation(segmentationId) {
+        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
     }
     _getViewportIdsForSegmentation(segmentationId) {
         const viewports = this._getAllViewports();
         const viewportIds = [];
         for (const viewport of viewports) {
             const viewportId = viewport.id;
-            const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+            const segmentationRepresentations = getSegmentationRepresentations(viewportId);
             if (segmentationId) {
                 const hasSegmentationRepresentation = segmentationRepresentations.some((representation) => representation.segmentationId === segmentationId);
                 if (hasSegmentationRepresentation) {
@@ -85,7 +83,7 @@ class SegmentationRenderingEngine {
         }
     }
     _triggerRender(viewportId) {
-        const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId);
         if (!segmentationRepresentations?.length) {
             return;
         }
@@ -132,5 +130,11 @@ class SegmentationRenderingEngine {
         }
     }
 }
+function triggerSegmentationRender(viewportId) {
+    segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+}
+function triggerSegmentationRenderBySegmentationId(segmentationId) {
+    segmentationRenderingEngine.renderSegmentation(segmentationId);
+}
 const segmentationRenderingEngine = new SegmentationRenderingEngine();
-export { segmentationRenderingEngine };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

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

@@ -12,31 +12,47 @@ export default class SegmentationStateManager {
     getSegmentation(segmentationId: string): Segmentation | undefined;
     addSegmentation(segmentation: Segmentation): void;
     removeSegmentation(segmentationId: string): void;
-    getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-    addRepresentation(segmentationRepresentation: SegmentationRepresentation): void;
-    addRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
-    updateSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+    addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
+    addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     private getLabelmapImageIds;
-    getLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string | undefined;
-    getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[];
+    getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
     removeRepresentation(segmentationRepresentationUID: string): void;
-    setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
-    getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
+    setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
+    getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
     getGlobalConfig(): SegmentationRepresentationConfig;
     setGlobalConfig(config: SegmentationRepresentationConfig): void;
     _getRepresentationConfig(segmentationRepresentationUID: string): {
         allSegments?: RepresentationConfig;
         perSegment?: SegmentRepresentationConfig;
     };
-    getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
+    getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
     getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
-    setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+    setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
     setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
-    getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-    setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+    getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+    setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
     _getStackIdForImageIds(imageIds: string[]): string;
 }
+declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+    imageIds: string[];
+    options?: {
+        volumeId?: string;
+    };
+}): Promise<{
+    volumeId: string;
+}>;
+declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
+    segmentationId: string;
+    options?: {
+        viewportId: string;
+        volumeId?: string;
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { defaultSegmentationStateManager };
+export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };