@cornerstonejs/tools 2.0.0-beta.17 → 2.0.0-beta.19

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

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

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

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

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

@@ -0,0 +1,23 @@
+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) {
+    segmentationRepresentationUIDs.forEach((segmentationDataUID) => {
+        _removeSegmentation(viewportId, segmentationDataUID, immediate);
+    });
+}
+function _removeSegmentation(viewportId, segmentationRepresentationUID, immediate) {
+    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
+    const { type } = segmentationRepresentation;
+    if (type === SegmentationRepresentations.Labelmap) {
+        labelmapDisplay.removeRepresentation(viewportId, segmentationRepresentationUID, immediate);
+    }
+    else if (type === SegmentationRepresentations.Contour) {
+        contourDisplay.removeRepresentation(viewportId, segmentationRepresentationUID, immediate);
+    }
+    else {
+        throw new Error(`The representation ${type} is not supported yet`);
+    }
+}
+export default removeRepresentationsFromViewport;

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

@@ -1,5 +1,6 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { invalidateBrushCursor } from '../../utilities/segmentation/';
-import { getSegmentation, getToolGroupIdsWithSegmentation, } from './segmentationState';
+import { getSegmentation, getViewportIdsWithSegmentationId, } from './segmentationState';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
@@ -11,9 +12,10 @@ function setActiveSegmentIndex(segmentationId, segmentIndex) {
         segmentation.activeSegmentIndex = segmentIndex;
         triggerSegmentationModified(segmentationId);
     }
-    const toolGroups = getToolGroupIdsWithSegmentation(segmentationId);
-    toolGroups.forEach((toolGroupId) => {
-        invalidateBrushCursor(toolGroupId);
+    const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const toolGroup = getToolGroupForViewport(viewportId);
+        invalidateBrushCursor(toolGroup.id);
     });
 }
 function getActiveSegmentIndex(segmentationId) {

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

@@ -1,33 +1,36 @@
 import type { Types } from '@cornerstonejs/core';
-import type { RepresentationConfig, Segmentation, SegmentationPublicInput, SegmentationRepresentationConfig, SegmentSpecificRepresentationConfig, ToolGroupSpecificRepresentation, ToolGroupSpecificRepresentations } from '../../types/SegmentationStateTypes';
+import type { RepresentationConfig, Segmentation, SegmentationPublicInput, SegmentationRepresentationConfig, SegmentRepresentationConfig, SegmentationRepresentation } from '../../types/SegmentationStateTypes';
 declare function getDefaultSegmentationStateManager(): import("./SegmentationStateManager").default;
 declare function getSegmentation(segmentationId: string): Segmentation | undefined;
 declare function getSegmentations(): Segmentation[] | [];
 declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentations | [];
-declare function getAllSegmentationRepresentations(): Record<string, ToolGroupSpecificRepresentation[]>;
-declare function getSegmentationIdRepresentations(segmentationId: any): any[];
-declare function findSegmentationRepresentationByUID(segmentationRepresentationUID: string): {
-    toolGroupId: string;
-    segmentationRepresentation: ToolGroupSpecificRepresentation;
+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 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): {
+    [segRepUID: string]: {
+        visible: boolean;
+        segmentsHidden: Set<number>;
+        active: boolean;
+    };
 };
-declare function getToolGroupIdsWithSegmentation(segmentationId: string): string[];
-declare function getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig;
-declare function setToolGroupSpecificConfig(toolGroupId: string, config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
-declare function setSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string): RepresentationConfig;
-declare function getSegmentSpecificRepresentationConfig(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-declare function setSegmentSpecificRepresentationConfig(toolGroupId: string, segmentationRepresentationUID: string, config: SegmentSpecificRepresentationConfig, suppressEvents?: boolean): void;
-declare function getToolGroupIdFromSegmentationRepresentationUID(segmentationRepresentationUID: string): string;
-declare function addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation, suppressEvents?: boolean): void;
+declare function addRepresentationToViewport(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
 declare function removeSegmentation(segmentationId: string): void;
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-declare function removeSegmentationRepresentations(toolGroupId: string): void;
+declare function removeRepresentation(segmentationRepresentationUID: string, suppressEvents?: boolean): void;
 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;
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getSegmentationRepresentations, addSegmentationRepresentation, removeSegmentationRepresentation, removeSegmentationRepresentations, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificRepresentationConfig, setSegmentSpecificRepresentationConfig, getToolGroupIdsWithSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentationByUID, getSegmentationIdRepresentations, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, findSegmentationRepresentationByUID, getToolGroupIdFromSegmentationRepresentationUID, };
+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;
+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, };

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

@@ -21,109 +21,71 @@ function addSegmentation(segmentationInput, suppressEvents) {
         triggerSegmentationModified(segmentation.segmentationId);
     }
 }
-function getSegmentationRepresentations(toolGroupId) {
+function getRepresentations() {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentations(toolGroupId);
+    const state = segmentationStateManager.getState();
+    return Object.values(state.representations);
 }
-function getAllSegmentationRepresentations() {
+function getRepresentation(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getAllSegmentationRepresentations();
+    return segmentationStateManager.getRepresentation(segmentationRepresentationUID);
 }
-function getSegmentationIdRepresentations(segmentationId) {
-    const allRepresentations = getAllSegmentationRepresentations() || {};
-    const foundRepresentations = [];
-    for (const toolGroupId in allRepresentations) {
-        const toolGroupRepresentations = allRepresentations[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationId === segmentationId);
-        if (foundRepresentation) {
-            foundRepresentations.push(foundRepresentation);
-        }
-    }
-    return foundRepresentations;
-}
-function findSegmentationRepresentationByUID(segmentationRepresentationUID) {
-    const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
-    const toolGroupIds = Object.keys(allToolGroupRepresentations);
-    for (const toolGroupId of toolGroupIds) {
-        const toolGroupRepresentations = getAllSegmentationRepresentations()[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        if (foundRepresentation) {
-            return {
-                segmentationRepresentation: foundRepresentation,
-                toolGroupId,
-            };
-        }
-    }
+function getRepresentationsBySegmentationId(segmentationId) {
+    const allRepresentations = getRepresentations();
+    return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
 }
-function getToolGroupIdsWithSegmentation(segmentationId) {
-    if (!segmentationId) {
-        throw new Error('getToolGroupIdsWithSegmentation: segmentationId is empty');
-    }
+function getAllSegmentsConfig(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    const toolGroupIds = Object.keys(state.toolGroups);
-    const foundToolGroupIds = [];
-    toolGroupIds.forEach((toolGroupId) => {
-        const toolGroupSegmentationRepresentations = segmentationStateManager.getSegmentationRepresentations(toolGroupId);
-        toolGroupSegmentationRepresentations.forEach((representation) => {
-            if (representation.segmentationId === segmentationId) {
-                foundToolGroupIds.push(toolGroupId);
-            }
-        });
-    });
-    return foundToolGroupIds;
-}
-function getToolGroupSpecificConfig(toolGroupId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getToolGroupSpecificConfig(toolGroupId);
+    return segmentationStateManager.getAllSegmentsConfig(segmentationRepresentationUID);
 }
-function setToolGroupSpecificConfig(toolGroupId, config, suppressEvents) {
+function setAllSegmentsConfig(segmentationRepresentationUID, config, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationConfig(toolGroupId, config);
+    segmentationStateManager.setAllSegmentsConfig(segmentationRepresentationUID, config);
     if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId);
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
-function setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config, suppressEvents = false) {
+function getPerSegmentConfig(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
-    }
+    return segmentationStateManager.getPerSegmentConfig(segmentationRepresentationUID);
 }
-function getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID) {
+function setPerSegmentConfig(segmentationRepresentationUID, config, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID);
+    segmentationStateManager.setPerSegmentConfig(segmentationRepresentationUID, config);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
 }
-function getSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, segmentIndex) {
+function getViewportIdsWithSegmentationId(segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex);
+    const state = segmentationStateManager.getState();
+    const viewports = state.viewports;
+    return Object.keys(viewports).filter((viewportId) => {
+        const viewport = viewports[viewportId];
+        return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
+    });
 }
-function setSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, config, suppressEvents = false) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+function getRepresentationsForViewport(viewportId) {
+    const viewportRenderingState = getRepresentationsRenderingStateForViewport(viewportId);
+    if (!viewportRenderingState) {
+        return [];
     }
+    const segRepUIDs = Object.keys(viewportRenderingState);
+    return segRepUIDs
+        .map((segRepUID) => getRepresentation(segRepUID))
+        .filter(Boolean);
 }
-function getToolGroupIdFromSegmentationRepresentationUID(segmentationRepresentationUID) {
-    const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
-    const toolGroupIds = Object.keys(allToolGroupRepresentations);
-    for (const toolGroupId of toolGroupIds) {
-        const toolGroupRepresentations = getAllSegmentationRepresentations()[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        if (foundRepresentation) {
-            return toolGroupId;
-        }
-    }
+function getRepresentationsRenderingStateForViewport(viewportId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    const state = segmentationStateManager.getState();
+    return state.viewports?.[viewportId] || {};
 }
-function addSegmentationRepresentation(toolGroupId, segmentationRepresentation, suppressEvents) {
+function addRepresentationToViewport(viewportId, segmentationRepresentation, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addSegmentationRepresentation(toolGroupId, segmentationRepresentation);
+    segmentationStateManager.addRepresentation(segmentationRepresentation);
+    segmentationStateManager.addRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
     if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentation.segmentationRepresentationUID);
+        triggerSegmentationRepresentationModified(segmentationRepresentation.segmentationRepresentationUID);
     }
 }
 function getGlobalConfig() {
@@ -137,25 +99,17 @@ function setGlobalConfig(config, suppressEvents) {
         triggerSegmentationModified();
     }
 }
-function getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-}
 function removeSegmentation(segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     segmentationStateManager.removeSegmentation(segmentationId);
     triggerSegmentationRemoved(segmentationId);
 }
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
+function removeRepresentation(segmentationRepresentationUID, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    triggerSegmentationRepresentationRemoved(toolGroupId, segmentationRepresentationUID);
-}
-function removeSegmentationRepresentations(toolGroupId) {
-    const segmentationRepresentations = getSegmentationRepresentations(toolGroupId) || [];
-    segmentationRepresentations.forEach((representation) => {
-        removeSegmentationRepresentation(toolGroupId, representation.segmentationRepresentationUID);
-    });
+    segmentationStateManager.removeRepresentation(segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationRemoved(segmentationRepresentationUID);
+    }
 }
 function removeColorLUT(colorLUTIndex) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
@@ -173,4 +127,23 @@ function addColorLUT(colorLUT, index) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     segmentationStateManager.addColorLUT(colorLUT, index);
 }
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getSegmentationRepresentations, addSegmentationRepresentation, removeSegmentationRepresentation, removeSegmentationRepresentations, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificRepresentationConfig, setSegmentSpecificRepresentationConfig, getToolGroupIdsWithSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentationByUID, getSegmentationIdRepresentations, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, findSegmentationRepresentationByUID, getToolGroupIdFromSegmentationRepresentationUID, };
+function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    return segmentationStateManager.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+}
+function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    segmentationStateManager.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
+}
+function getActiveRepresentation(viewportId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    return segmentationStateManager.getActiveRepresentation(viewportId);
+}
+function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    segmentationStateManager.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
+}
+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, };

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

@@ -1,6 +1,6 @@
 declare function triggerSegmentationRemoved(segmentationId: string): void;
-declare function triggerSegmentationRepresentationRemoved(toolGroupId: string, segmentationRepresentationUID: string): void;
-declare function triggerSegmentationRepresentationModified(toolGroupId: string, segmentationRepresentationUID?: string): void;
+declare function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID: string): void;
+declare function triggerSegmentationRepresentationModified(segmentationRepresentationUID: string): void;
 declare function triggerSegmentationModified(segmentationId?: string): void;
 declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;
 export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

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

@@ -1,6 +1,6 @@
 import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getSegmentationRepresentations, getSegmentations, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentations } from '../../stateManagement/segmentation/segmentationState';
 import { setSegmentationDirty } from '../../utilities/segmentation/getUniqueSegmentIndices';
 function triggerSegmentationRemoved(segmentationId) {
     const eventDetail = {
@@ -8,31 +8,17 @@ function triggerSegmentationRemoved(segmentationId) {
     };
     triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
 }
-function triggerSegmentationRepresentationRemoved(toolGroupId, segmentationRepresentationUID) {
+function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID) {
     const eventDetail = {
-        toolGroupId,
         segmentationRepresentationUID,
     };
     triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
 }
-function triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID) {
+function triggerSegmentationRepresentationModified(segmentationRepresentationUID) {
     const eventDetail = {
-        toolGroupId,
         segmentationRepresentationUID,
     };
-    if (segmentationRepresentationUID) {
-        triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
-        return;
-    }
-    const segmentationRepresentations = getSegmentationRepresentations(toolGroupId) || [];
-    segmentationRepresentations.forEach((segmentationRepresentation) => {
-        const { segmentationRepresentationUID } = segmentationRepresentation;
-        const eventDetail = {
-            toolGroupId,
-            segmentationRepresentationUID,
-        };
-        triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
-    });
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
 }
 function triggerSegmentationModified(segmentationId) {
     let segmentationIds;

package/dist/esm/store/ToolGroupManager/destroyToolGroup.js

@@ -1,11 +1,7 @@
 import { state } from '../index';
-import { removeSegmentationsFromToolGroup } from '../../stateManagement/segmentation';
-import { segmentationRenderingEngine } from '../../utilities/segmentation/triggerSegmentationRender';
 function destroyToolGroup(toolGroupId) {
     const toolGroupIndex = state.toolGroups.findIndex((tg) => tg.id === toolGroupId);
     if (toolGroupIndex > -1) {
-        segmentationRenderingEngine.removeToolGroup(toolGroupId);
-        removeSegmentationsFromToolGroup(toolGroupId);
         state.toolGroups.splice(toolGroupIndex, 1);
     }
 }

package/dist/esm/tools/AdvancedMagnifyViewport.js

@@ -4,7 +4,7 @@ import { SegmentationRepresentations, ToolModes, Events as cstEvents, } from '..
 import { ToolGroupManager, state } from '../store';
 import { debounce } from '../utilities';
 import { segmentation } from '..';
-import { AnnotationTool, AdvancedMagnifyTool, SegmentationDisplayTool, } from './';
+import { AnnotationTool, AdvancedMagnifyTool } from './';
 import { distanceToPoint } from '../utilities/math/point';
 const MAGNIFY_CLASSNAME = 'advancedMagnifyTool';
 const MAGNIFY_VIEWPORT_INITIAL_RADIUS = 125;
@@ -147,11 +147,11 @@ class AdvancedMagnifyViewport {
             const toolInstance = sourceToolGroup.getToolInstance(toolName);
             const isAnnotationTool = toolInstance instanceof AnnotationTool &&
                 !(toolInstance instanceof AdvancedMagnifyTool);
-            return (isAnnotationTool || toolName === SegmentationDisplayTool.toolName);
+            return isAnnotationTool;
         });
         magnifyToolGroup.addViewport(magnifyViewport.id, magnifyViewport.renderingEngineId);
         sourceActors.filter(isSegmentation).forEach((actor) => {
-            segmentation.addSegmentationRepresentations(magnifyToolGroupId, [
+            segmentation.addRepresentations(this.viewportId, [
                 {
                     segmentationId: actor.referencedId,
                     type: SegmentationRepresentations.Labelmap,

package/dist/esm/tools/ScaleOverlayTool.d.ts

@@ -1,7 +1,7 @@
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 import { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 declare class ScaleOverlayTool extends AnnotationDisplayTool {
     static toolName: any;
     touchDragCallback: any;

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

@@ -609,13 +609,13 @@ class BidirectionalTool extends AnnotationTool {
                 const index4 = transformWorldToIndex(imageData, worldPos4);
                 const handles1 = [index1, index2];
                 const handles2 = [index3, index4];
-                const { scale: scale1, units: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
-                const { scale: scale2, units: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
+                const { scale: scale1, lengthUnits: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
+                const { scale: scale2, lengthUnits: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
                 const dist1 = this._calculateLength(worldPos1, worldPos2) / scale1;
                 const dist2 = this._calculateLength(worldPos3, worldPos4) / scale2;
                 const length = dist1 > dist2 ? dist1 : dist2;
                 const width = dist1 > dist2 ? dist2 : dist1;
-                const lengthUnit = dist1 > dist2 ? units1 : units2;
+                const lengthUnits = dist1 > dist2 ? units1 : units2;
                 const widthUnit = dist1 > dist2 ? units2 : units1;
                 this._isInsideVolume(index1, index2, index3, index4, dimensions)
                     ? (this.isHandleOutsideImage = false)
@@ -623,8 +623,7 @@ class BidirectionalTool extends AnnotationTool {
                 cachedStats[targetId] = {
                     length,
                     width,
-                    unit: units1,
-                    lengthUnit,
+                    lengthUnits,
                     widthUnit,
                 };
             }
@@ -714,7 +713,7 @@ class BidirectionalTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;
-    const { length, width, unit, lengthUnit, widthUnit } = cachedStats[targetId];
+    const { length, width, unit, lengthUnits, widthUnit } = cachedStats[targetId];
     const textLines = [];
     if (label) {
         textLines.push(label);
@@ -722,7 +721,7 @@ function defaultGetTextLines(data, targetId) {
     if (length === undefined) {
         return textLines;
     }
-    textLines.push(`L: ${roundNumber(length)} ${lengthUnit || unit}`, `W: ${roundNumber(width)} ${widthUnit || unit}`);
+    textLines.push(`L: ${roundNumber(length)} ${lengthUnits || unit}`, `W: ${roundNumber(width)} ${widthUnit || unit}`);
     return textLines;
 }
 BidirectionalTool.toolName = 'Bidirectional';

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

@@ -16,7 +16,7 @@ import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorld
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { pointInShapeCallback } from '../../utilities';
-import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
 import { pointInEllipse } from '../../utilities/math/ellipse';
@@ -347,14 +347,14 @@ class CircleROITool extends AnnotationTool {
                 const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit == null) {
+                    data.cachedStats[targetId].areaUnits == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnit: null,
+                        areaUnits: null,
                         radius: null,
                         radiusUnit: null,
                         perimeter: null,
@@ -508,16 +508,16 @@ class CircleROITool extends AnnotationTool {
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                     const handles = [pos1Index, pos2Index];
-                    const { scale, units, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { scale, lengthUnits, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
                     const aspect = getCalibratedAspect(image);
                     const area = Math.abs(Math.PI *
                         (worldWidth / scale / 2) *
                         (worldHeight / aspect / scale / 2));
-                    const modalityUnitOptions = {
+                    const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = pointInShapeCallback(imageData, (pointLPS) => pointInEllipse(ellipseObj, pointLPS, {
                         fast: true,
                     }), this.configuration.statsCalculator.statsCallback, boundsIJK);
@@ -531,11 +531,11 @@ class CircleROITool extends AnnotationTool {
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
                         isEmptyArea,
-                        areaUnit: areaUnits,
+                        areaUnits,
                         radius: worldWidth / 2 / scale,
-                        radiusUnit: units,
+                        radiusUnit: lengthUnits,
                         perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
-                        modalityUnit,
+                        pixelValueUnits,
                     };
                 }
                 else {
@@ -558,7 +558,7 @@ class CircleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats;
+    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits, } = cachedVolumeStats;
     const textLines = [];
     if (radius) {
         const radiusLine = isEmptyArea
@@ -569,17 +569,17 @@ function defaultGetTextLines(data, targetId) {
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${roundNumber(area)} ${areaUnit}`;
+            : `Area: ${roundNumber(area)} ${areaUnits}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+        textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
     }
     if (max) {
-        textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+        textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     }
     return textLines;
 }

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

@@ -84,7 +84,7 @@ class DragProbeTool extends ProbeTool {
                 annotation,
                 styleSpecifier,
             });
-            const modalityUnitOptions = {
+            const pixelUnitsOptions = {
                 isPreScaled: isViewportPreScaled(viewport, targetId),
                 isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
             };
@@ -122,13 +122,13 @@ class DragProbeTool extends ProbeTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, modalityUnit } = cachedVolumeStats;
+    const { index, value, pixelValueUnits } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+    textLines.push(`${value.toFixed(2)} ${pixelValueUnits}`);
     return textLines;
 }
 DragProbeTool.toolName = 'DragProbe';