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

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

@@ -59,15 +59,15 @@ export default class SegmentationStateManager {
     removeSegmentation(segmentationId) {
         this.state.segmentations = this.state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
     }
-    getRepresentation(segmentationRepresentationUID) {
+    getSegmentationRepresentation(segmentationRepresentationUID) {
         return this.state.representations[segmentationRepresentationUID];
     }
-    addRepresentation(segmentationRepresentation) {
+    addSegmentationRepresentationState(segmentationRepresentation) {
         const { segmentationRepresentationUID } = segmentationRepresentation;
         this.state.representations[segmentationRepresentationUID] =
             segmentationRepresentation;
     }
-    addRepresentationToViewport(viewportId, segmentationRepresentationUID) {
+    addSegmentationRepresentationToViewport(viewportId, segmentationRepresentationUID) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
             return;
@@ -75,20 +75,25 @@ export default class SegmentationStateManager {
         if (!this.state.viewports[viewportId]) {
             this.state.viewports[viewportId] = {};
         }
-        const representation = this.getRepresentation(segmentationRepresentationUID);
+        const representation = this.getSegmentationRepresentation(segmentationRepresentationUID);
         if (representation.type !== SegmentationRepresentations.Labelmap) {
-            this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+            this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
             return;
         }
         const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
         const segmentation = this.getSegmentation(representation.segmentationId);
         const { representationData } = segmentation;
+        const isLabelmap = representationData.LABELMAP;
+        if (!isLabelmap) {
+            this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
+            return;
+        }
         const isBaseVolumeSegmentation = 'volumeId' in representationData.LABELMAP;
         if (!volumeViewport) {
             if (isBaseVolumeSegmentation) {
             }
             else {
-                this.updateSegmentationImageReferences(viewportId, segmentation.segmentationId);
+                this.updateLabelmapSegmentationImageReferences(viewportId, segmentation.segmentationId);
             }
         }
         else {
@@ -104,9 +109,9 @@ export default class SegmentationStateManager {
             else {
             }
         }
-        this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+        this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     }
-    updateSegmentationImageReferences(viewportId, segmentationId) {
+    updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
         const segmentation = this.getSegmentation(segmentationId);
         if (!segmentation) {
             return;
@@ -115,6 +120,9 @@ export default class SegmentationStateManager {
             this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
         }
         const { representationData } = segmentation;
+        if (!representationData.LABELMAP) {
+            return;
+        }
         const labelmapImageIds = this.getLabelmapImageIds(representationData);
         const enabledElement = getEnabledElementByViewportId(viewportId);
         const stackViewport = enabledElement.viewport;
@@ -147,7 +155,7 @@ export default class SegmentationStateManager {
         }
         return labelmapImageIds;
     }
-    getLabelmapImageIdsForViewport(viewportId, segmentationId) {
+    getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
             return;
@@ -160,13 +168,13 @@ export default class SegmentationStateManager {
         const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
         return imageIdReferenceMap.get(currentImageId);
     }
-    getRepresentationsForViewport(viewportId) {
+    getSegmentationRepresentations(viewportId) {
         const viewport = this.state.viewports[viewportId];
         if (!viewport) {
             return [];
         }
         return Object.keys(viewport).map((segRepUID) => {
-            return this.getRepresentation(segRepUID);
+            return this.getSegmentationRepresentation(segRepUID);
         });
     }
     removeRepresentation(segmentationRepresentationUID) {
@@ -175,7 +183,7 @@ export default class SegmentationStateManager {
             delete this.state.viewports[viewportId][segmentationRepresentationUID];
         });
     }
-    setActiveRepresentation(viewportId, segmentationRepresentationUID) {
+    setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID) {
         Object.keys(this.state.viewports[viewportId]).forEach((segRepUID) => {
             this.state.viewports[viewportId][segRepUID].active = false;
         });
@@ -192,7 +200,7 @@ export default class SegmentationStateManager {
         this.state.viewports[viewportId][segmentationRepresentationUID].active =
             true;
     }
-    getActiveRepresentation(viewportId) {
+    getActiveSegmentationRepresentation(viewportId) {
         if (!this.state.viewports?.[viewportId]) {
             return;
         }
@@ -200,7 +208,7 @@ export default class SegmentationStateManager {
         if (!activeSegRep) {
             return;
         }
-        return this.getRepresentation(activeSegRep[0]);
+        return this.getSegmentationRepresentation(activeSegRep[0]);
     }
     getGlobalConfig() {
         return this.state.globalConfig;
@@ -209,13 +217,13 @@ export default class SegmentationStateManager {
         this.state.globalConfig = config;
     }
     _getRepresentationConfig(segmentationRepresentationUID) {
-        const segmentationRepresentation = this.getRepresentation(segmentationRepresentationUID);
+        const segmentationRepresentation = this.getSegmentationRepresentation(segmentationRepresentationUID);
         if (!segmentationRepresentation) {
             return;
         }
         return segmentationRepresentation.config;
     }
-    getAllSegmentsConfig(segmentationRepresentationUID) {
+    getSegmentationRepresentationConfig(segmentationRepresentationUID) {
         const config = this._getRepresentationConfig(segmentationRepresentationUID);
         if (!config) {
             return;
@@ -229,7 +237,7 @@ export default class SegmentationStateManager {
         }
         return config.perSegment;
     }
-    setAllSegmentsConfig(segmentationRepresentationUID, config) {
+    setSegmentationRepresentationConfig(segmentationRepresentationUID, config) {
         const _config = this._getRepresentationConfig(segmentationRepresentationUID);
         if (!_config) {
             return;
@@ -243,11 +251,11 @@ export default class SegmentationStateManager {
         }
         _config.perSegment = config;
     }
-    getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
         const viewport = this.state.viewports[viewportId];
         return viewport && viewport[segmentationRepresentationUID]?.visible;
     }
-    setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+    setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
         if (!this.state.viewports[viewportId]) {
             this.state.viewports[viewportId] = {};
         }

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

@@ -1,4 +1,5 @@
-import { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
-declare function getActiveRepresentation(viewportId: any): SegmentationRepresentation;
-declare function setActiveRepresentation(viewportId: any, segmentationRepresentationUID: any, suppressEvent?: boolean): void;
-export { getActiveRepresentation, setActiveRepresentation, };
+import type { SegmentationRepresentation, Segmentation } from '../../types/SegmentationStateTypes';
+declare function getActiveSegmentationRepresentation(viewportId: any): SegmentationRepresentation;
+declare function getActiveSegmentation(viewportId: any): Segmentation;
+declare function setActiveSegmentationRepresentation(viewportId: any, segmentationRepresentationUID: any, suppressEvent?: boolean): void;
+export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };

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

@@ -1,8 +1,15 @@
 import * as SegmentationState from './segmentationState';
-function getActiveRepresentation(viewportId) {
-    return SegmentationState.getActiveRepresentation(viewportId);
+function getActiveSegmentationRepresentation(viewportId) {
+    return SegmentationState.getActiveSegmentationRepresentation(viewportId);
 }
-function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
-    SegmentationState.setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
+function getActiveSegmentation(viewportId) {
+    const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
+    if (!activeRepresentation) {
+        return null;
+    }
+    return SegmentationState.getSegmentation(activeRepresentation.segmentationId);
 }
-export { getActiveRepresentation, setActiveRepresentation, };
+function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
+    SegmentationState.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
+}
+export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };

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

@@ -1,6 +1,6 @@
-import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
-import { ContourSegmentationData } from '../../types/ContourTypes';
-import { SurfaceSegmentationData } from '../../types/SurfaceTypes';
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import type { ContourSegmentationData } from '../../types/ContourTypes';
+import type { SurfaceSegmentationData } from '../../types/SurfaceTypes';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 type SegmentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
 type AddRepresentationData = {

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addSegmentationRepresentation(viewportId: string, representationInput: RepresentationPublicInput, initialConfig?: SegmentationRepresentationConfig): Promise<string>;
+export { addSegmentationRepresentation };

package/dist/esm/stateManagement/segmentation/{addRepresentation.js → addSegmentationRepresentation.js}

@@ -1,11 +1,11 @@
 import { utilities } from '@cornerstonejs/core';
 import * as SegmentationState from './segmentationState';
-import { getRepresentationRenderingConfig } from './helpers/getRepresentationRenderingConfig';
+import { getSegmentationRepresentationRenderingConfig } from './helpers/getSegmentationRepresentationRenderingConfig';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 import { triggerAnnotationRenderForViewportIds } from '../../utilities';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
-async function addRepresentation(viewportId, representationInput, initialConfig) {
+async function addSegmentationRepresentation(viewportId, representationInput, initialConfig) {
     const { segmentationId, options = {} } = representationInput;
     const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
         utilities.uuidv4();
@@ -15,16 +15,16 @@ async function addRepresentation(viewportId, representationInput, initialConfig)
         segmentationRepresentationUID,
         type: representationInput.type,
         colorLUTIndex: colorLUTIndexToUse,
-        rendering: getRepresentationRenderingConfig(representationInput),
+        rendering: getSegmentationRepresentationRenderingConfig(representationInput),
         polySeg: options.polySeg,
         config: {
             allSegments: {},
             perSegment: {},
         },
     };
-    SegmentationState.addRepresentationToViewport(viewportId, representation);
+    SegmentationState.addSegmentationRepresentation(viewportId, representation);
     if (initialConfig) {
-        SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, initialConfig.representations);
+        SegmentationState.setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig.representations);
     }
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
@@ -48,4 +48,4 @@ function getColorLUTIndex(options = {}) {
     }
     return colorLUTIndexToUse;
 }
-export { addRepresentation };
+export { addSegmentationRepresentation };

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addSegmentationRepresentations(viewportId: string, representationInputArray: RepresentationPublicInput[], segmentationRepresentationConfig?: SegmentationRepresentationConfig): Promise<string[]>;
+export default addSegmentationRepresentations;

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

@@ -0,0 +1,9 @@
+import { addSegmentationRepresentation } from './addSegmentationRepresentation';
+async function addSegmentationRepresentations(viewportId, representationInputArray, segmentationRepresentationConfig) {
+    const promises = representationInputArray.map((representationInput) => {
+        return addSegmentationRepresentation(viewportId, representationInput, segmentationRepresentationConfig);
+    });
+    const segmentationRepresentationUIDs = await Promise.all(promises);
+    return segmentationRepresentationUIDs;
+}
+export default addSegmentationRepresentations;

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

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
 declare function addSegmentations(segmentationInputArray: SegmentationPublicInput[]): void;
 export default addSegmentations;

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

@@ -1,4 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/index.js

@@ -1,4 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/segmentationColor.js

@@ -12,7 +12,7 @@ function addColorLUT(colorLUT, colorLUTIndex) {
     SegmentationState.addColorLUT(colorLUT, colorLUTIndex);
 }
 function setColorLUT(segmentationRepresentationUID, colorLUTIndex) {
-    const segRepresentation = SegmentationState.getRepresentation(segmentationRepresentationUID);
+    const segRepresentation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
     if (!segRepresentation) {
         throw new Error(`setColorLUT: could not find segmentation representation with UID ${segmentationRepresentationUID}`);
     }
@@ -23,7 +23,7 @@ function setColorLUT(segmentationRepresentationUID, colorLUTIndex) {
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function getSegmentIndexColor(segmentationRepresentationUID, segmentIndex) {
-    const segmentationRepresentation = SegmentationState.getRepresentation(segmentationRepresentationUID);
+    const segmentationRepresentation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
     if (!segmentationRepresentation) {
         throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist`);
     }

package/dist/esm/stateManagement/segmentation/config/segmentationConfig.d.ts

@@ -1,13 +1,13 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { RepresentationConfig, SegmentationRepresentationConfig, SegmentRepresentationConfig } from '../../../types/SegmentationStateTypes';
+import type SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentRepresentationConfig } from '../../../types/SegmentationStateTypes';
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(segmentationConfig: SegmentationRepresentationConfig): void;
 declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): RepresentationConfig['LABELMAP'];
 declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig['LABELMAP']): void;
-declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
-declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+declare function getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
+declare function setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
 declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
 declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
 declare function setSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number, config: RepresentationConfig, suppressEvent?: boolean): void;
 declare function getSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/segmentationConfig.js

@@ -23,11 +23,11 @@ function setGlobalRepresentationConfig(representationType, config) {
         },
     });
 }
-function getAllSegmentsConfig(segmentationRepresentationUID) {
-    return SegmentationState.getAllSegmentsConfig(segmentationRepresentationUID);
+function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
+    return SegmentationState.getSegmentationRepresentationConfig(segmentationRepresentationUID);
 }
-function setAllSegmentsConfig(segmentationRepresentationUID, config) {
-    SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, config);
+function setSegmentationRepresentationConfig(segmentationRepresentationUID, config) {
+    SegmentationState.setSegmentationRepresentationConfig(segmentationRepresentationUID, config);
 }
 function setPerSegmentConfig(segmentationRepresentationUID, config) {
     SegmentationState.setPerSegmentConfig(segmentationRepresentationUID, config);
@@ -46,4 +46,4 @@ function getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex) {
     const perSegment = SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
     return perSegment?.[segmentIndex];
 }
-export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.d.ts

@@ -1,7 +1,7 @@
-declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visibility: boolean): void;
-declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean | undefined;
-declare function setSegmentsVisibility(viewport: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
+declare function setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visibility: boolean): void;
+declare function getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean | undefined;
+declare function setSegmentIndicesVisibility(viewport: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
 declare function setSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number, visibility: boolean): void;
 declare function getSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number): boolean;
-declare function getSegmentsHidden(viewportId: string, segmentationRepresentationUID: string): Set<number>;
-export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };
+declare function getHiddenSegmentIndices(viewportId: string, segmentationRepresentationUID: string): Set<number>;
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js

@@ -1,18 +1,18 @@
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
-function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
-    const representation = SegmentationState.getRepresentation(segmentationRepresentationUID);
+function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
+    const representation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
     if (!representation) {
         return;
     }
-    SegmentationState.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
+    SegmentationState.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    return SegmentationState.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    return SegmentationState.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
 }
-function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
-    const hiddenSegments = getSegmentsHidden(viewport, segmentationRepresentationUID);
+function setSegmentIndicesVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
+    const hiddenSegments = getHiddenSegmentIndices(viewport, segmentationRepresentationUID);
     segmentIndices.forEach((segmentIndex) => {
         visibility
             ? hiddenSegments.delete(segmentIndex)
@@ -21,22 +21,22 @@ function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentI
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function setSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex, visibility) {
-    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
     visibility
         ? hiddenSegments.delete(segmentIndex)
         : hiddenSegments.add(segmentIndex);
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex) {
-    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
     return !hiddenSegments.has(segmentIndex);
 }
-function getSegmentsHidden(viewportId, segmentationRepresentationUID) {
-    const viewportRenderingState = SegmentationState.getRepresentationsRenderingStateForViewport(viewportId);
+function getHiddenSegmentIndices(viewportId, segmentationRepresentationUID) {
+    const viewportRenderingState = SegmentationState.getSegmentationRepresentationViewportStates(viewportId);
     if (!viewportRenderingState) {
         return new Set();
     }
     return (viewportRenderingState[segmentationRepresentationUID]?.segmentsHidden ??
         new Set());
 }
-export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

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

@@ -1,17 +1,13 @@
 import { volumeLoader, utilities as csUtils, eventTarget, cache, } from '@cornerstonejs/core';
-import { Events } from '../../enums';
+import { Events, SegmentationRepresentations } from '../../enums';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import { triggerSegmentationRender } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
 async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
     const segmentationImageIds = imageIds;
-    const additionalDetails = {
-        imageIds,
-    };
     const volumeId = options?.volumeId ?? csUtils.uuidv4();
-    await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds, {
-        additionalDetails,
-    });
+    await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds);
     return { volumeId };
 }
 async function convertStackToVolumeSegmentation({ segmentationId, options, }) {

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

@@ -1,35 +1,22 @@
-import { cache, eventTarget, getRenderingEngines, } from '@cornerstonejs/core';
+import { cache, eventTarget } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
-import addRepresentations from './addRepresentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import { triggerSegmentationRender } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
 export async function computeStackSegmentationFromVolume({ volumeId, }) {
     const segmentationVolume = cache.getVolume(volumeId);
-    const hasCachedImages = segmentationVolume.imageCacheOffsetMap.size > 0;
-    let isAllImagesCached = false;
-    if (hasCachedImages) {
-        isAllImagesCached = segmentationVolume.imageIds.every((imageId) => cache.getImage(imageId));
-    }
-    const renderingEngine = getRenderingEngines()[0];
-    const volumeUsedInOtherViewports = renderingEngine
-        .getVolumeViewports()
-        .find((vp) => vp.hasVolumeId(volumeId));
-    segmentationVolume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-    const imageIds = _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume);
-    return { imageIds };
+    return { imageIds: segmentationVolume.imageIds };
 }
 export async function convertVolumeToStackSegmentation({ segmentationId, options, }) {
     const segmentation = getSegmentation(segmentationId);
-    const data = segmentation.representationData
+    const { volumeId } = segmentation.representationData
         .LABELMAP;
-    const { imageIds } = await computeStackSegmentationFromVolume({
-        volumeId: data.volumeId,
-    });
+    const segmentationVolume = cache.getVolume(volumeId);
     await updateStackSegmentationState({
         segmentationId,
         viewportId: options.viewportId,
-        imageIds,
+        imageIds: segmentationVolume.imageIds,
         options,
     });
 }
@@ -51,44 +38,12 @@ export async function updateStackSegmentationState({ segmentationId, viewportId,
             imageIds,
         };
     }
-    await addRepresentations(viewportId, [
+    await addSegmentationRepresentations(viewportId, [
         {
             segmentationId,
             type: SegmentationRepresentations.Labelmap,
         },
     ]);
-    triggerSegmentationRender();
+    triggerSegmentationRender(viewportId);
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
-function _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume) {
-    if (segmentationVolume.additionalDetails?.imageIds) {
-        return segmentationVolume.additionalDetails.imageIds;
-    }
-    else if (segmentationVolume.referencedImageIds?.length &&
-        !segmentationVolume.referencedImageIds[0].startsWith('derived')) {
-        const segmentationImageIds = segmentationVolume.imageIds;
-        return [...segmentationImageIds].reverse();
-    }
-    else {
-        const referencedVolumeId = segmentationVolume.referencedVolumeId;
-        const referencedVolume = cache.getVolume(referencedVolumeId);
-        if (!referencedVolume) {
-            throw new Error('Cannot convert volumetric segmentation without referenced volume to stack segmentation yet');
-        }
-        if (!referencedVolume?.imageIds?.length) {
-            throw new Error('Cannot convert volumetric segmentation without imageIds to stack segmentation yet');
-        }
-        if (referencedVolume.imageIds?.[0].startsWith('derived')) {
-            throw new Error(`Cannot convert volume segmentation that is derived from another segmentation
-         to stack segmentation yet, include the additionalDetails.imageIds
-         in the volume segmentation in case you need it for the conversion`);
-        }
-        const referencedImageIds = referencedVolume.imageIds;
-        let segmentationImageIdsToUse = segmentationVolume.imageIds;
-        if (!segmentationImageIdsToUse?.length) {
-            segmentationImageIdsToUse =
-                segmentationVolume.convertToImageSlicesAndCache();
-        }
-        return [...segmentationImageIdsToUse].reverse();
-    }
-}

package/dist/esm/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export type SurfacesInfo = {
     id: string;
     points: number[];

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationRepresentationRenderingConfig.d.ts

@@ -0,0 +1,2 @@
+import type { RepresentationPublicInput } from '../../../types';
+export declare function getSegmentationRepresentationRenderingConfig(representationInput: RepresentationPublicInput): {};

package/dist/esm/stateManagement/segmentation/helpers/{getRepresentationRenderingConfig.js → getSegmentationRepresentationRenderingConfig.js}

@@ -1,6 +1,6 @@
 import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { getRepresentationRenderingConfig as getLabelmapRenderingConfig } from '../../../tools/displayTools/Labelmap/labelmapDisplay';
-export function getRepresentationRenderingConfig(representationInput) {
+import { getSegmentationRepresentationRenderingConfig as getLabelmapRenderingConfig } from '../../../tools/displayTools/Labelmap/labelmapDisplay';
+export function getSegmentationRepresentationRenderingConfig(representationInput) {
     const { type } = representationInput;
     if (type === SegmentationRepresentations.Labelmap) {
         return getLabelmapRenderingConfig();

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
 declare function normalizeSegmentationInput(segmentationInput: SegmentationPublicInput): Segmentation;
 export default normalizeSegmentationInput;

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
 declare function validateSegmentationInput(segmentationInputArray: SegmentationPublicInput[]): void;
 export default validateSegmentationInput;

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

@@ -1,6 +1,6 @@
-import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
+import removeSegmentationRepresentations from './removeSegmentationRepresentations';
 import addSegmentations from './addSegmentations';
-import addRepresentations from './addRepresentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import addRepresentationData from './addRepresentationData';
 import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
@@ -11,4 +11,4 @@ import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

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

@@ -1,6 +1,6 @@
-import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
+import removeSegmentationRepresentations from './removeSegmentationRepresentations';
 import addSegmentations from './addSegmentations';
-import addRepresentations from './addRepresentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import addRepresentationData from './addRepresentationData';
 import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
@@ -11,4 +11,4 @@ import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.d.ts

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

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.d.ts

@@ -1,5 +1,5 @@
-import { PolySegConversionOptions } from '../../../../types';
-import { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
+import type { PolySegConversionOptions } from '../../../../types';
+import type { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
 export type RawContourData = Map<number, SurfaceClipResult[]>;
 export declare function computeContourData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
     annotationUIDsMap: Map<number, Set<string>>;