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

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.js

@@ -1,10 +1,11 @@
 import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, setAllSegmentsConfig } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
 import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
-import { clipAndCacheSurfacesForViewport, } from '../../helpers/clipAndCacheSurfacesForViewport';
+import { clipAndCacheSurfacesForViewport } from '../../helpers/clipAndCacheSurfacesForViewport';
 import { extractContourData } from './utils/extractContourData';
 import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
+import { getSegmentation } from '../../getSegmentation';
+import { setSegmentationRepresentationConfig } from '../../setSegmentationRepresentationConfig';
 export async function computeContourData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -35,7 +36,7 @@ export async function computeContourData(segmentationId, options = {}) {
     }
     const { viewport, segmentationRepresentationUID } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    setAllSegmentsConfig(segmentationRepresentationUID, {
+    setSegmentationRepresentationConfig(segmentationRepresentationUID, {
         CONTOUR: {
             fillAlpha: 0,
         },

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.d.ts

@@ -1,3 +1,3 @@
-import { RawContourData } from '../contourComputationStrategies';
+import type { RawContourData } from '../contourComputationStrategies';
 import { type Types } from '@cornerstonejs/core';
 export declare function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData: RawContourData, viewport: Types.IViewport, segmentationId: string): Map<number, Set<string>>;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js

@@ -1,4 +1,4 @@
-import { PlanarFreehandContourSegmentationTool } from '../../../../../tools';
+import PlanarFreehandContourSegmentationTool from '../../../../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { addAnnotation } from '../../../../annotation/annotationState';
 import { utilities } from '@cornerstonejs/core';
 export function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId) {

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.d.ts

@@ -1,3 +1,3 @@
-import { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
-import { RawContourData } from '../contourComputationStrategies';
+import type { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import type { RawContourData } from '../contourComputationStrategies';
 export declare function extractContourData(polyDataCache: PolyDataClipCacheType, segmentIndexMap?: Map<string, number>): RawContourData;

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

@@ -1,2 +1,2 @@
-import { PolySegConversionOptions } from '../../../../types';
+import type { PolySegConversionOptions } from '../../../../types';
 export declare function computeAndAddLabelmapRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<import("./labelmapComputationStrategies").RawLabelmapData>;

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

@@ -1,4 +1,4 @@
-import { ContourSegmentationData, PolySegConversionOptions } from '../../../../types';
+import type { ContourSegmentationData, PolySegConversionOptions } from '../../../../types';
 export declare function convertContourToVolumeLabelmap(contourRepresentationData: ContourSegmentationData, options?: PolySegConversionOptions): Promise<{
     volumeId: string;
 }>;

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

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import { cache, utilities, getWebWorkerManager, volumeLoader, imageLoader, metaData, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
-import { getAnnotation } from '../../..';
+import { getAnnotation } from '../../../annotation/annotationState';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
 const triggerWorkerProgress = (eventTarget, progress) => {
@@ -10,29 +10,23 @@ const triggerWorkerProgress = (eventTarget, progress) => {
     });
 };
 export async function convertContourToVolumeLabelmap(contourRepresentationData, options = {}) {
-    const { viewport } = options;
+    const viewport = options.viewport;
+    const volumeId = viewport.getVolumeId();
     const imageIds = utilities.getViewportImageIds(viewport);
     if (!imageIds) {
         throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
     }
     const segmentationVolumeId = utilities.uuidv4();
-    const volumeProps = utilities.generateVolumePropsFromImageIds(imageIds, segmentationVolumeId);
-    const { metadata, dimensions, origin, direction, spacing, scalarData } = volumeProps;
-    const segmentationVolume = await volumeLoader.createLocalSegmentationVolume({
-        dimensions,
-        origin,
-        direction,
-        spacing,
-        metadata,
-        imageIds: imageIds.map((imageId) => `generated://${imageId}`),
-        referencedImageIds: imageIds,
-    }, segmentationVolumeId);
+    const segmentationVolume = volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId, {
+        volumeId: segmentationVolumeId,
+    });
+    const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     triggerWorkerProgress(eventTarget, 0);
     const newScalarData = await workerManager.executeTask('polySeg', 'convertContourToVolumeLabelmap', {
         segmentIndices,
         dimensions,
-        scalarData,
+        scalarData: voxelManager.getCompleteScalarDataArray?.(),
         origin,
         direction,
         spacing,
@@ -45,11 +39,7 @@ export async function convertContourToVolumeLabelmap(contourRepresentationData,
         ],
     });
     triggerWorkerProgress(eventTarget, 1);
-    segmentationVolume.imageData
-        .getPointData()
-        .getScalars()
-        .setData(newScalarData);
-    segmentationVolume.imageData.modified();
+    voxelManager.setCompleteScalarDataArray(newScalarData);
     segmentationVolume.modified();
     return {
         volumeId: segmentationVolume.volumeId,
@@ -69,7 +59,8 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             throw new Error('ImageIds must be cached before converting contour to labelmap');
         }
     });
-    const { imageIds: segmentationImageIds } = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const segImages = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const segmentationImageIds = segImages.map((it) => it.imageId);
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     const segmentationsInfo = new Map();
     segmentationImageIds.forEach((segImageId, index) => {
@@ -92,7 +83,7 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             direction,
             spacing,
             origin,
-            scalarData: segImage.getPixelData(),
+            scalarData: segImage.voxelManager.getScalarData(),
             imageId: segImageId,
             dimensions: [segImage.width, segImage.height, 1],
         });
@@ -115,7 +106,7 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
         const segmentationInfo = segmentationsInfo.get(referencedImageId);
         const { imageId: segImageId } = segmentationInfo;
         const segImage = cache.getImage(segImageId);
-        segImage.getPixelData().set(scalarData);
+        segImage.voxelManager.getScalarData().set(scalarData);
         segImage.imageFrame?.pixelData?.set(scalarData);
         segImageIds.push(segImageId);
     });

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

@@ -1,5 +1,5 @@
-import { Types } from '@cornerstonejs/core';
-import { SurfaceSegmentationData } from '../../../../types/SurfaceTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { SurfaceSegmentationData } from '../../../../types/SurfaceTypes';
 export declare function convertSurfaceToVolumeLabelmap(surfaceRepresentationData: SurfaceSegmentationData, segmentationVolume: Types.IImageVolume): Promise<{
     volumeId: string;
 }>;

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

@@ -23,7 +23,7 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
             polys,
         });
     });
-    const { dimensions, direction, origin, spacing } = segmentationVolume;
+    const { dimensions, direction, origin, spacing, voxelManager } = segmentationVolume;
     triggerWorkerProgress(eventTarget, 0);
     const newScalarData = await workerManager.executeTask('polySeg', 'convertSurfacesToVolumeLabelmap', {
         segmentsInfo,
@@ -39,11 +39,7 @@ export async function convertSurfaceToVolumeLabelmap(surfaceRepresentationData,
         ],
     });
     triggerWorkerProgress(eventTarget, 1);
-    segmentationVolume.imageData
-        .getPointData()
-        .getScalars()
-        .setData(newScalarData);
-    segmentationVolume.imageData.modified();
+    voxelManager.setCompleteScalarDataArray(newScalarData);
     segmentationVolume.modified();
     return {
         volumeId: segmentationVolume.volumeId,

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

@@ -1,5 +1,5 @@
-import { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
-import { PolySegConversionOptions } from '../../../../types';
+import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from '../../../../types/LabelmapTypes';
+import type { PolySegConversionOptions } from '../../../../types';
 export type RawLabelmapData = LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack;
 export declare function computeLabelmapData(segmentationId: string, options?: PolySegConversionOptions): Promise<RawLabelmapData>;
 declare function computeLabelmapFromContourSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack>;

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

@@ -1,6 +1,6 @@
-import { VolumeViewport, volumeLoader, utilities } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation } from '../../segmentationState';
+import { VolumeViewport, volumeLoader, imageLoader } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+import { getSegmentation } from '../../getSegmentation';
 import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
 import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
 import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
@@ -55,7 +55,8 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
     return result;
 }
 async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
-    const isVolume = options.viewport instanceof VolumeViewport ?? true;
+    const { viewport } = options;
+    const isVolume = viewport instanceof VolumeViewport ?? true;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
@@ -67,26 +68,20 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
             segmentsGeometryIds.set(segmentIndex, geometryId);
         }
     });
-    if (isVolume && !options.viewport) {
+    if (isVolume && !viewport) {
         throw new Error('Cannot compute labelmap from surface segmentation without providing the viewport');
     }
     let segmentationVolume;
     if (isVolume) {
-        const defaultActor = options.viewport.getDefaultActor();
-        const { uid: volumeId } = defaultActor;
+        const volumeId = viewport.getVolumeId();
         segmentationVolume =
             await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();
-        const volumeId = 'generatedSegmentationVolumeId';
-        const volumeProps = utilities.generateVolumePropsFromImageIds(imageIds, volumeId);
-        delete volumeProps.imageIds;
-        segmentationVolume = await volumeLoader.createLocalSegmentationVolume({
-            ...volumeProps,
-            scalarData: volumeProps.scalarData,
-            referencedImageIds: imageIds,
-        }, volumeId);
+        const segImages = imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+        const segImageIds = segImages.map((image) => image.imageId);
+        segmentationVolume = await volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
     }
     const result = await convertSurfaceToVolumeLabelmap({ geometryIds: segmentsGeometryIds }, segmentationVolume);
     if (isVolume) {

package/dist/esm/stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation.d.ts

@@ -1,4 +1,4 @@
-import { PolySegConversionOptions } from '../../../../types';
+import type { PolySegConversionOptions } from '../../../../types';
 export declare function computeAndAddSurfaceRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<{
     geometryIds: Map<number, string>;
 }>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertContourToSurface.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { ContourSegmentationData } from '../../../../types';
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationData } from '../../../../types';
 export declare function convertContourToSurface(contourRepresentationData: ContourSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

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

@@ -16,7 +16,8 @@ export async function convertContourToSurface(contourRepresentationData, segment
     const annotationUIDs = annotationUIDsMap.get(segmentIndex);
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
-        const { polyline } = annotation.data.contour;
+        const { polyline } = annotation.data
+            .contour;
         numPointsArray.push(polyline.length);
         polyline.forEach((polyline) => polylines.push(...polyline));
     }

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
 export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number, isVolume?: boolean): Promise<Types.SurfaceData>;

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

@@ -1,6 +1,5 @@
-import { cache, eventTarget, triggerEvent, Enums, } from '@cornerstonejs/core';
-import { getWebWorkerManager } from '@cornerstonejs/core';
-import { computeVolumeSegmentationFromStack } from '../../convertStackToVolumeSegmentation';
+import { cache, eventTarget, getWebWorkerManager, triggerEvent, Enums, } from '@cornerstonejs/core';
+import { computeVolumeSegmentationFromStack } from '../../SegmentationStateManager';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
 const triggerWorkerProgress = (eventTarget, progress) => {
@@ -22,7 +21,7 @@ export async function convertLabelmapToSurface(labelmapRepresentationData, segme
         }));
     }
     const volume = cache.getVolume(volumeId);
-    const scalarData = volume.getScalarData();
+    const scalarData = volume.voxelManager.getCompleteScalarDataArray();
     const { dimensions, spacing, origin, direction } = volume;
     triggerWorkerProgress(eventTarget, 0);
     const results = await workerManager.executeTask('polySeg', 'convertLabelmapToSurface', {

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.d.ts

@@ -1,5 +1,5 @@
-import { RawSurfacesData } from './surfaceComputationStrategies';
-import { PolySegConversionOptions } from '../../../../types';
+import type { RawSurfacesData } from './surfaceComputationStrategies';
+import type { PolySegConversionOptions } from '../../../../types';
 export declare function createAndCacheSurfacesFromRaw(segmentationId: string, rawSurfacesData: RawSurfacesData, options?: PolySegConversionOptions): Promise<{
     geometryIds: Map<number, string>;
 }>;

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

@@ -1,10 +1,11 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
 import { getSegmentIndexColor } from '../../config/segmentationColor';
-import { getRepresentation, getSegmentation } from '../../segmentationState';
+import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
+import { getSegmentation } from '../../getSegmentation';
 export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
     let segmentationRepresentation;
     if (options.segmentationRepresentationUID) {
-        segmentationRepresentation = getRepresentation(options.segmentationRepresentationUID);
+        segmentationRepresentation = getSegmentationRepresentation(options.segmentationRepresentationUID);
     }
     const segmentation = getSegmentation(segmentationId);
     const geometryIds = new Map();

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { PolySegConversionOptions } from '../../../../types';
+import type { PolySegConversionOptions } from '../../../../types';
 export type RawSurfacesData = {
     segmentIndex: number;
     data: Types.SurfaceData;

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

@@ -1,5 +1,5 @@
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+import { getSegmentation } from '../../getSegmentation';
 import { convertContourToSurface } from './convertContourToSurface';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
 import { isVolumeSegmentation } from '../../../../tools/segmentation/strategies/utils/stackVolumeCheck';

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

@@ -1,6 +1,6 @@
 import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../segmentationState';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
+import { getSegmentation, getSegmentationRepresentations, getViewportIdsWithSegmentation, } from '../../segmentationState';
 import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
@@ -27,9 +27,9 @@ export async function updateSurfaceData(segmentationId) {
         const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
         const geometry = cache.getGeometry(geometryId);
         if (!geometry) {
-            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
             return viewportIds.map((viewportId) => {
-                const segmentationRepresentations = getRepresentationsForViewport(viewportId);
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
                 return segmentationRepresentations.map((segmentationRepresentation) => {
                     if (segmentationRepresentation.type !==
                         SegmentationRepresentations.Surface) {

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.js

@@ -1,6 +1,7 @@
 import { SegmentationRepresentations } from '../../../enums';
-import { validateLabelmap } from '../../../tools/displayTools/Labelmap';
-import { getRepresentation, getSegmentation } from '../segmentationState';
+import { getSegmentation } from '../getSegmentation';
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
+import { validate as validateLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 const conversionPaths = new Map([
     [
         SegmentationRepresentations.Labelmap,
@@ -22,7 +23,7 @@ const conversionPaths = new Map([
     ],
 ]);
 function canComputeRequestedRepresentation(segmentationRepresentationUID) {
-    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
+    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     const { type: representationType, polySeg } = segmentationRepresentation;
     if (!polySeg || !polySeg.enabled) {
         return false;

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationRepresentations } from '../../../enums';
+import type { SegmentationRepresentations } from '../../../enums';
 declare function computeAndAddRepresentation<T>(segmentationId: string, representationType: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void): Promise<T>;
 export { computeAndAddRepresentation };

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.js

@@ -2,7 +2,7 @@ import { eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../../enums';
 import addRepresentationData from '../addRepresentationData';
 import { triggerSegmentationModified } from '../triggerSegmentationEvents';
-import { debounce } from '../../../utilities';
+import debounce from '../../../utilities/debounce';
 import { registerPolySegWorker } from './registerPolySegWorker';
 const computedRepresentations = new Map();
 async function computeAndAddRepresentation(segmentationId, representationType, computeFunction, updateFunction) {

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

@@ -0,0 +1 @@
+export declare function removeColorLUT(colorLUTIndex: number): void;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function removeColorLUT(colorLUTIndex) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.removeColorLUT(colorLUTIndex);
+}

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

@@ -0,0 +1 @@
+export declare function removeRepresentation(segmentationRepresentationUID: string, suppressEvents?: boolean): void;

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

@@ -0,0 +1,9 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRepresentationRemoved } from './triggerSegmentationEvents';
+export function removeRepresentation(segmentationRepresentationUID, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.removeRepresentation(segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationRemoved(segmentationRepresentationUID);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function removeSegmentation(segmentationId: string): void;

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

@@ -0,0 +1,7 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRemoved } from './triggerSegmentationEvents';
+export function removeSegmentation(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.removeSegmentation(segmentationId);
+    triggerSegmentationRemoved(segmentationId);
+}

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

@@ -0,0 +1,2 @@
+declare function removeSegmentationRepresentations(viewportId: string, segmentationRepresentationUIDs?: string[] | undefined, immediate?: boolean): void;
+export default removeSegmentationRepresentations;

package/dist/esm/stateManagement/segmentation/{removeRepresentationsFromViewport.js → removeSegmentationRepresentations.js}

@@ -1,14 +1,17 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
-import { contourDisplay } from '../../tools/displayTools/Contour';
-import { getRepresentation } from './segmentationState';
-function removeRepresentationsFromViewport(viewportId, segmentationRepresentationUIDs, immediate) {
+import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
+import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
+import { getSegmentationRepresentation } from './segmentationState';
+function removeSegmentationRepresentations(viewportId, segmentationRepresentationUIDs, immediate) {
+    if (!segmentationRepresentationUIDs) {
+        return;
+    }
     segmentationRepresentationUIDs.forEach((segmentationDataUID) => {
-        _removeSegmentation(viewportId, segmentationDataUID, immediate);
+        _removeRepresentation(viewportId, segmentationDataUID, immediate);
     });
 }
-function _removeSegmentation(viewportId, segmentationRepresentationUID, immediate) {
-    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
+function _removeRepresentation(viewportId, segmentationRepresentationUID, immediate) {
+    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     const { type } = segmentationRepresentation;
     if (type === SegmentationRepresentations.Labelmap) {
         labelmapDisplay.removeRepresentation(viewportId, segmentationRepresentationUID, immediate);
@@ -20,4 +23,4 @@ function _removeSegmentation(viewportId, segmentationRepresentationUID, immediat
         throw new Error(`The representation ${type} is not supported yet`);
     }
 }
-export default removeRepresentationsFromViewport;
+export default removeSegmentationRepresentations;

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

@@ -1,3 +1,3 @@
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
 declare function setActiveSegmentIndex(segmentationId: string, segmentIndex: number): void;
-declare function getActiveSegmentIndex(segmentationId: string): number | undefined;
-export { getActiveSegmentIndex, setActiveSegmentIndex };
+export { setActiveSegmentIndex, getActiveSegmentIndex };

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

@@ -1,7 +1,9 @@
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
-import { invalidateBrushCursor } from '../../utilities/segmentation/';
-import { getSegmentation, getViewportIdsWithSegmentationId, } from './segmentationState';
+import { invalidateBrushCursor } from '../../utilities/segmentation/invalidateBrushCursor';
+import { getSegmentation } from './getSegmentation';
+import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (typeof segmentIndex === 'string') {
@@ -12,16 +14,10 @@ function setActiveSegmentIndex(segmentationId, segmentIndex) {
         segmentation.activeSegmentIndex = segmentIndex;
         triggerSegmentationModified(segmentationId);
     }
-    const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+    const viewportIds = getViewportIdsWithSegmentation(segmentationId);
     viewportIds.forEach((viewportId) => {
         const toolGroup = getToolGroupForViewport(viewportId);
         invalidateBrushCursor(toolGroup.id);
     });
 }
-function getActiveSegmentIndex(segmentationId) {
-    const segmentation = getSegmentation(segmentationId);
-    if (segmentation) {
-        return segmentation.activeSegmentIndex;
-    }
-}
-export { getActiveSegmentIndex, setActiveSegmentIndex };
+export { setActiveSegmentIndex, getActiveSegmentIndex };

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

@@ -1,4 +1,4 @@
 declare function isSegmentIndexLocked(segmentationId: string, segmentIndex: number): boolean;
 declare function setSegmentIndexLocked(segmentationId: string, segmentIndex: number, locked?: boolean): void;
-declare function getLockedSegments(segmentationId: string): number[] | [];
-export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegments };
+declare function getLockedSegmentIndices(segmentationId: string): number[] | [];
+export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegmentIndices };

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

@@ -1,4 +1,4 @@
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 function isSegmentIndexLocked(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
@@ -22,7 +22,7 @@ function setSegmentIndexLocked(segmentationId, segmentIndex, locked = true) {
     }
     triggerSegmentationModified(segmentationId);
 }
-function getLockedSegments(segmentationId) {
+function getLockedSegmentIndices(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
@@ -30,4 +30,4 @@ function getLockedSegments(segmentationId) {
     const { segmentsLocked } = segmentation;
     return Array.from(segmentsLocked);
 }
-export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegments };
+export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegmentIndices };