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

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

@@ -1,8 +1,8 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, setAllSegmentsConfig } from '../../segmentationState';
+import { getSegmentation, setSegmentationRepresentationConfig, } from '../../segmentationState';
 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';
 export async function computeContourData(segmentationId, options = {}) {
@@ -35,7 +35,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/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

@@ -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,4 +1,4 @@
-import { VolumeViewport, volumeLoader, utilities } from '@cornerstonejs/core';
+import { VolumeViewport, volumeLoader, utilities, imageLoader, } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
 import { getSegmentation } from '../../segmentationState';
 import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
@@ -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,4 +1,4 @@
-import { cache, eventTarget, triggerEvent, Enums, } from '@cornerstonejs/core';
+import { cache, eventTarget, triggerEvent, Enums } from '@cornerstonejs/core';
 import { getWebWorkerManager } from '@cornerstonejs/core';
 import { computeVolumeSegmentationFromStack } from '../../convertStackToVolumeSegmentation';
 import { WorkerTypes } from '../../../../enums';
@@ -22,7 +22,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,10 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
 import { getSegmentIndexColor } from '../../config/segmentationColor';
-import { getRepresentation, getSegmentation } from '../../segmentationState';
+import { getSegmentationRepresentation, getSegmentation, } from '../../segmentationState';
 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/updateSurfaceData.js

@@ -1,10 +1,11 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../segmentationState';
+import { getSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentations, getViewportIdsWithSegmentation, } from '../../segmentationState';
 import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
+import { viewport } from '../../../../utilities';
 export async function updateSurfaceData(segmentationId) {
     const surfacesObj = await computeSurfaceFromLabelmapSegmentation(segmentationId);
     if (!surfacesObj) {
@@ -27,9 +28,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,6 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { validateLabelmap } from '../../../tools/displayTools/Labelmap';
-import { getRepresentation, getSegmentation } from '../segmentationState';
+import { getSegmentationRepresentation, getSegmentation, } from '../segmentationState';
 const conversionPaths = new Map([
     [
         SegmentationRepresentations.Labelmap,
@@ -22,7 +22,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/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 { 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.js

@@ -1,6 +1,6 @@
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { invalidateBrushCursor } from '../../utilities/segmentation/';
-import { getSegmentation, getViewportIdsWithSegmentationId, } from './segmentationState';
+import { getSegmentation, getViewportIdsWithSegmentation, } from './segmentationState';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
@@ -12,7 +12,7 @@ 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);

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

@@ -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 };

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

@@ -4,23 +4,23 @@ declare function getDefaultSegmentationStateManager(): import("./SegmentationSta
 declare function getSegmentation(segmentationId: string): Segmentation | undefined;
 declare function getSegmentations(): Segmentation[] | [];
 declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;
-declare function getRepresentations(): SegmentationRepresentation[];
-declare function getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-declare function getRepresentationsBySegmentationId(segmentationId: string): SegmentationRepresentation[];
-declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
-declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
+declare function getAllSegmentationRepresentations(): SegmentationRepresentation[];
+declare function getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+declare function getSegmentationRepresentationsForSegmentation(segmentationId: string): SegmentationRepresentation[];
+declare function getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
+declare function setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
 declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
 declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;
-declare function getViewportIdsWithSegmentationId(segmentationId: string): string[];
-declare function getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[] | [];
-declare function getRepresentationsRenderingStateForViewport(viewportId: string): {
+declare function getViewportIdsWithSegmentation(segmentationId: string): string[];
+declare function getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[] | [];
+declare function getSegmentationRepresentationViewportStates(viewportId: string): {
     [segRepUID: string]: {
         visible: boolean;
         segmentsHidden: Set<number>;
         active: boolean;
     };
 };
-declare function addRepresentationToViewport(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;
+declare function addSegmentationRepresentation(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
 declare function removeSegmentation(segmentationId: string): void;
@@ -29,10 +29,10 @@ declare function removeColorLUT(colorLUTIndex: number): void;
 declare function getColorLUT(index: number): Types.ColorLUT | undefined;
 declare function getNextColorLUTIndex(): number;
 declare function addColorLUT(colorLUT: Types.ColorLUT, index: number): void;
-declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
-declare function getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-declare function setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;
-declare function getLabelmapImageIdsForViewport(viewportId: string, segmentationId?: string): string;
-declare function updateSegmentationImageReferences(viewportId: string, segmentationId: string): void;
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };
+declare function getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+declare function setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+declare function getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
+declare function setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;
+declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId?: string): string;
+declare function updateLabelmapSegmentationImageReferences(viewportId: string, segmentationId: string): void;
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };

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

@@ -21,26 +21,26 @@ function addSegmentation(segmentationInput, suppressEvents) {
         triggerSegmentationModified(segmentation.segmentationId);
     }
 }
-function getRepresentations() {
+function getAllSegmentationRepresentations() {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     const state = segmentationStateManager.getState();
     return Object.values(state.representations);
 }
-function getRepresentation(segmentationRepresentationUID) {
+function getSegmentationRepresentation(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getRepresentation(segmentationRepresentationUID);
+    return segmentationStateManager.getSegmentationRepresentation(segmentationRepresentationUID);
 }
-function getRepresentationsBySegmentationId(segmentationId) {
-    const allRepresentations = getRepresentations();
+function getSegmentationRepresentationsForSegmentation(segmentationId) {
+    const allRepresentations = getAllSegmentationRepresentations();
     return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
 }
-function getAllSegmentsConfig(segmentationRepresentationUID) {
+function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getAllSegmentsConfig(segmentationRepresentationUID);
+    return segmentationStateManager.getSegmentationRepresentationConfig(segmentationRepresentationUID);
 }
-function setAllSegmentsConfig(segmentationRepresentationUID, config, suppressEvents) {
+function setSegmentationRepresentationConfig(segmentationRepresentationUID, config, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setAllSegmentsConfig(segmentationRepresentationUID, config);
+    segmentationStateManager.setSegmentationRepresentationConfig(segmentationRepresentationUID, config);
     if (!suppressEvents) {
         triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
@@ -56,7 +56,7 @@ function setPerSegmentConfig(segmentationRepresentationUID, config, suppressEven
         triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
-function getViewportIdsWithSegmentationId(segmentationId) {
+function getViewportIdsWithSegmentation(segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     const state = segmentationStateManager.getState();
     const viewports = state.viewports;
@@ -65,25 +65,25 @@ function getViewportIdsWithSegmentationId(segmentationId) {
         return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
     });
 }
-function getRepresentationsForViewport(viewportId) {
-    const viewportRenderingState = getRepresentationsRenderingStateForViewport(viewportId);
+function getSegmentationRepresentations(viewportId) {
+    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
     if (!viewportRenderingState) {
         return [];
     }
     const segRepUIDs = Object.keys(viewportRenderingState);
     return segRepUIDs
-        .map((segRepUID) => getRepresentation(segRepUID))
+        .map((segRepUID) => getSegmentationRepresentation(segRepUID))
         .filter(Boolean);
 }
-function getRepresentationsRenderingStateForViewport(viewportId) {
+function getSegmentationRepresentationViewportStates(viewportId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     const state = segmentationStateManager.getState();
     return state.viewports?.[viewportId] || {};
 }
-function addRepresentationToViewport(viewportId, segmentationRepresentation, suppressEvents) {
+function addSegmentationRepresentation(viewportId, segmentationRepresentation, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addRepresentation(segmentationRepresentation);
-    segmentationStateManager.addRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
+    segmentationStateManager.addSegmentationRepresentationState(segmentationRepresentation);
+    segmentationStateManager.addSegmentationRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
     if (!suppressEvents) {
         triggerSegmentationRepresentationModified(segmentationRepresentation.segmentationRepresentationUID);
     }
@@ -127,31 +127,31 @@ function addColorLUT(colorLUT, index) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     segmentationStateManager.addColorLUT(colorLUT, index);
 }
-function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
 }
-function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
+    segmentationStateManager.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
 }
-function getActiveRepresentation(viewportId) {
+function getActiveSegmentationRepresentation(viewportId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getActiveRepresentation(viewportId);
+    return segmentationStateManager.getActiveSegmentationRepresentation(viewportId);
 }
-function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
+function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+    segmentationStateManager.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     if (!suppressEvents) {
         triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
-function getLabelmapImageIdsForViewport(viewportId, segmentationId) {
+function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getLabelmapImageIdsForViewport(viewportId, segmentationId);
+    return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
 }
-function updateSegmentationImageReferences(viewportId, segmentationId) {
+function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.updateSegmentationImageReferences(viewportId, segmentationId);
+    segmentationStateManager.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
 }
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, getLabelmapImageIdsForViewport, updateSegmentationImageReferences, };
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };