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

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.js

@@ -1,30 +1,34 @@
-import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, StackViewport, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
-    let modifiedSlices = modifiedSlicesToUse;
     const { representationData, type } = SegmentationState.getSegmentation(segmentationId);
-    const labelmapRepresentationData = representationData[type];
-    if ('stack' in labelmapRepresentationData &&
-        'volumeId' in labelmapRepresentationData) {
-        modifiedSlices = [];
-    }
-    if ('volumeId' in labelmapRepresentationData) {
-        performVolumeLabelmapUpdate({
-            modifiedSlicesToUse: modifiedSlices,
-            representationData,
-            type,
-        });
-    }
     const viewportIds = SegmentationState.getViewportIdsWithSegmentation(segmentationId);
-    if ('imageIds' in labelmapRepresentationData) {
-        performStackLabelmapUpdate({
-            viewportIds,
-            segmentationId,
-            representationData,
-            type,
-        });
-    }
+    const hasVolumeViewport = viewportIds.some((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        return viewport instanceof VolumeViewport;
+    });
+    const hasStackViewport = viewportIds.some((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        return viewport instanceof StackViewport;
+    });
+    const hasBothStackAndVolume = hasVolumeViewport && hasStackViewport;
+    viewportIds.forEach((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        if (viewport instanceof VolumeViewport) {
+            performVolumeLabelmapUpdate({
+                modifiedSlicesToUse: hasBothStackAndVolume ? [] : modifiedSlicesToUse,
+                representationData,
+                type,
+            });
+        }
+        if (viewport instanceof StackViewport) {
+            performStackLabelmapUpdate({
+                viewportIds,
+                segmentationId,
+            });
+        }
+    });
 };
 function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData, type, }) {
     const segmentationVolume = cache.getVolume(representationData[type].volumeId);
@@ -46,7 +50,7 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
     });
     imageData.modified();
 }
-function performStackLabelmapUpdate({ viewportIds, segmentationId, representationData, type, }) {
+function performStackLabelmapUpdate({ viewportIds, segmentationId }) {
     viewportIds.forEach((viewportId) => {
         const viewportSegReps = SegmentationState.getSegmentationRepresentations(viewportId);
         viewportSegReps.forEach((representation) => {

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.js

@@ -1,10 +1,10 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
 import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;
-    const { type } = SegmentationState.getSegmentation(segmentationId);
+    const { type } = getSegmentation(segmentationId);
     if (type === SegmentationRepresentations.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

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

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

package/dist/esm/stateManagement/index.js

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

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

@@ -1,4 +1,3 @@
-import type { Types } from '@cornerstonejs/core';
 declare class SegmentationRenderingEngine {
     private _needsRender;
     private _animationFrameSet;
@@ -6,7 +5,7 @@ declare class SegmentationRenderingEngine {
     hasBeenDestroyed: boolean;
     renderSegmentationsForViewport(viewportId?: string): void;
     renderSegmentation(segmentationId: string): void;
-    _getAllViewports: () => Types.IViewport[];
+    _getAllViewports: () => import("@cornerstonejs/core").Viewport[];
     _getViewportIdsForSegmentation(segmentationId?: string): string[];
     private _throwIfDestroyed;
     private _setViewportsToBeRenderedNextFrame;

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

@@ -15,9 +15,12 @@ export default class SegmentationStateManager {
     getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
     addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
     addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    _updateLabelmapSegmentationReferences(segmentationId: any, stackViewport: any, labelmapImageIds: any, updateCallback: any): string;
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     private getLabelmapImageIds;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
     getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
     removeRepresentation(segmentationRepresentationUID: string): void;
     setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;

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

@@ -111,6 +111,23 @@ export default class SegmentationStateManager {
         }
         this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     }
+    _updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, updateCallback) {
+        const currentImageId = stackViewport.getCurrentImageId();
+        for (const labelmapImageId of labelmapImageIds) {
+            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            if (viewableImageId) {
+                this._stackLabelmapImageIdReferenceMap
+                    .get(segmentationId)
+                    .set(currentImageId, labelmapImageId);
+            }
+        }
+        if (updateCallback) {
+            updateCallback(stackViewport, segmentationId, labelmapImageIds);
+        }
+        return this._stackLabelmapImageIdReferenceMap
+            .get(segmentationId)
+            .get(currentImageId);
+    }
     updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
         const segmentation = this.getSegmentation(segmentationId);
         if (!segmentation) {
@@ -126,18 +143,36 @@ export default class SegmentationStateManager {
         const labelmapImageIds = this.getLabelmapImageIds(representationData);
         const enabledElement = getEnabledElementByViewportId(viewportId);
         const stackViewport = enabledElement.viewport;
-        const currentImageId = stackViewport.getCurrentImageId();
-        for (const labelmapImageId of labelmapImageIds) {
-            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
-            if (viewableImageId) {
-                this._stackLabelmapImageIdReferenceMap
-                    .get(segmentationId)
-                    .set(currentImageId, labelmapImageId);
-            }
+        return this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, null);
+    }
+    _updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
         }
-        return this._stackLabelmapImageIdReferenceMap
-            .get(segmentationId)
-            .get(currentImageId);
+        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            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;
+        this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
+            const imageIds = stackViewport.getImageIds();
+            imageIds.forEach((imageId, index) => {
+                for (const labelmapImageId of labelmapImageIds) {
+                    const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId, sliceIndex: index }, { asOverlay: true, withNavigation: true });
+                    if (viewableImageId) {
+                        this._stackLabelmapImageIdReferenceMap
+                            .get(segmentationId)
+                            .set(imageId, labelmapImageId);
+                    }
+                }
+            });
+        });
     }
     getLabelmapImageIds(representationData) {
         const labelmapData = representationData.LABELMAP;
@@ -168,6 +203,19 @@ export default class SegmentationStateManager {
         const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
         return imageIdReferenceMap.get(currentImageId);
     }
+    getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return [];
+        }
+        this._updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const imageIds = viewport.getImageIds();
+        const associatedReferenceImageAndLabelmapImageIds = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
+        return imageIds.map((imageId) => {
+            return associatedReferenceImageAndLabelmapImageIds.get(imageId);
+        });
+    }
     getSegmentationRepresentations(viewportId) {
         const viewport = this.state.viewports[viewportId];
         if (!viewport) {

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

@@ -0,0 +1 @@
+export declare function getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];

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

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

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

@@ -26,4 +26,5 @@ import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepr
 import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
-export { 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, };
+import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
+export { 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, getStackSegmentationImageIdsForViewport, };

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

@@ -26,4 +26,5 @@ import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepr
 import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
-export { 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, };
+import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
+export { 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, getStackSegmentationImageIdsForViewport, };

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

@@ -608,13 +608,13 @@ class BidirectionalTool extends AnnotationTool {
                 const index4 = transformWorldToIndex(imageData, worldPos4);
                 const handles1 = [index1, index2];
                 const handles2 = [index3, index4];
-                const { scale: scale1, lengthUnits: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
-                const { scale: scale2, lengthUnits: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
+                const { scale: scale1, unit: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
+                const { scale: scale2, unit: 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 lengthUnits = dist1 > dist2 ? units1 : units2;
+                const unit = dist1 > dist2 ? units1 : units2;
                 const widthUnit = dist1 > dist2 ? units2 : units1;
                 this._isInsideVolume(index1, index2, index3, index4, dimensions)
                     ? (this.isHandleOutsideImage = false)
@@ -622,7 +622,7 @@ class BidirectionalTool extends AnnotationTool {
                 cachedStats[targetId] = {
                     length,
                     width,
-                    lengthUnits,
+                    unit,
                     widthUnit,
                 };
             }
@@ -712,7 +712,7 @@ class BidirectionalTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;
-    const { length, width, unit, lengthUnits, widthUnit } = cachedStats[targetId];
+    const { length, width, unit } = cachedStats[targetId];
     const textLines = [];
     if (label) {
         textLines.push(label);
@@ -720,7 +720,7 @@ function defaultGetTextLines(data, targetId) {
     if (length === undefined) {
         return textLines;
     }
-    textLines.push(`L: ${csUtils.roundNumber(length)} ${lengthUnits || unit}`, `W: ${csUtils.roundNumber(width)} ${widthUnit || unit}`);
+    textLines.push(`L: ${csUtils.roundNumber(length)} ${unit || unit}`, `W: ${csUtils.roundNumber(width)} ${unit}`);
     return textLines;
 }
 BidirectionalTool.toolName = 'Bidirectional';

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

@@ -346,14 +346,14 @@ class CircleROITool extends AnnotationTool {
                 const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                         radius: null,
                         radiusUnit: null,
                         perimeter: null,
@@ -507,7 +507,7 @@ class CircleROITool extends AnnotationTool {
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                     const handles = [pos1Index, pos2Index];
-                    const { scale, lengthUnits, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { scale, unit, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                     const aspect = getCalibratedAspect(image);
                     const area = Math.abs(Math.PI *
                         (worldWidth / scale / 2) *
@@ -516,7 +516,7 @@ class CircleROITool extends AnnotationTool {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                         isInObject: (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }),
                         boundsIJK,
@@ -533,11 +533,11 @@ class CircleROITool extends AnnotationTool {
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
                         isEmptyArea,
-                        areaUnits,
+                        areaUnit,
                         radius: worldWidth / 2 / scale,
-                        radiusUnit: lengthUnits,
+                        radiusUnit: unit,
                         perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
-                        pixelValueUnits,
+                        modalityUnit,
                     };
                 }
                 else {
@@ -560,7 +560,7 @@ class CircleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits, } = cachedVolumeStats;
+    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats;
     const textLines = [];
     if (radius) {
         const radiusLine = isEmptyArea
@@ -571,17 +571,17 @@ function defaultGetTextLines(data, targetId) {
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${csUtils.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
     }
     if (max) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     }
     return textLines;
 }

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

@@ -117,13 +117,13 @@ class DragProbeTool extends ProbeTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, pixelValueUnits } = cachedVolumeStats;
+    const { index, value, modalityUnit } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    textLines.push(`${value.toFixed(2)} ${pixelValueUnits}`);
+    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
     return textLines;
 }
 DragProbeTool.toolName = 'DragProbe';

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

@@ -427,14 +427,14 @@ class EllipticalROITool extends AnnotationTool {
                 const canvasCorners = (getCanvasEllipseCorners(canvasCoordinates));
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                     };
                     this._calculateCachedStats(annotation, viewport, renderingEngine);
                 }
@@ -587,7 +587,7 @@ class EllipticalROITool extends AnnotationTool {
                 const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                 const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                 const handles = [pos1Index, post2Index];
-                const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                 const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
                     scale /
                     scale;
@@ -595,7 +595,7 @@ class EllipticalROITool extends AnnotationTool {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
-                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                     boundsIJK,
                     imageData,
@@ -612,8 +612,8 @@ class EllipticalROITool extends AnnotationTool {
                     statsArray: stats.array,
                     pointsInShape,
                     isEmptyArea,
-                    areaUnits,
-                    pixelValueUnits,
+                    areaUnit,
+                    modalityUnit,
                 };
             }
             annotation.invalidated = false;
@@ -651,22 +651,22 @@ class EllipticalROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits } = cachedVolumeStats;
+    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${csUtils.roundNumber(area)} ${areaUnits}`;
+            : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
     }
     if (max) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     }
     return textLines;
 }

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

@@ -403,13 +403,13 @@ class HeightTool extends AnnotationTool {
             const index1 = transformWorldToIndex(imageData, worldPos1);
             const index2 = transformWorldToIndex(imageData, worldPos2);
             const handles = [index1, index2];
-            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+            const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
             const height = this._calculateHeight(worldPos1, worldPos2) / scale;
             const outside = this._isInsideVolume(index1, index2, dimensions);
             this.isHandleOutsideImage = outside;
             cachedStats[targetId] = {
                 height,
-                lengthUnits,
+                unit,
             };
         }
         annotation.invalidated = false;
@@ -423,11 +423,11 @@ class HeightTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { height, lengthUnits } = cachedVolumeStats;
+    const { height, unit } = cachedVolumeStats;
     if (height === undefined || height === null || isNaN(height)) {
         return;
     }
-    const textLines = [`${csUtils.roundNumber(height)} ${lengthUnits}`];
+    const textLines = [`${csUtils.roundNumber(height)} ${unit}`];
     return textLines;
 }
 HeightTool.toolName = 'Height';

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

@@ -394,14 +394,14 @@ class LengthTool extends AnnotationTool {
             const index1 = transformWorldToIndex(imageData, worldPos1);
             const index2 = transformWorldToIndex(imageData, worldPos2);
             const handles = [index1, index2];
-            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+            const { scale, unit } = getCalibratedLengthUnitsAndScale(image, handles);
             const length = this._calculateLength(worldPos1, worldPos2) / scale;
             this._isInsideVolume(index1, index2, dimensions)
                 ? (this.isHandleOutsideImage = false)
                 : (this.isHandleOutsideImage = true);
             cachedStats[targetId] = {
                 length,
-                lengthUnits,
+                unit,
             };
         }
         annotation.invalidated = false;
@@ -415,11 +415,11 @@ class LengthTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { length, lengthUnits } = cachedVolumeStats;
+    const { length, unit } = cachedVolumeStats;
     if (length === undefined || length === null || isNaN(length)) {
         return;
     }
-    const textLines = [`${csUtils.roundNumber(length)} ${lengthUnits}`];
+    const textLines = [`${csUtils.roundNumber(length)} ${unit}`];
     return textLines;
 }
 LengthTool.toolName = 'Length';

package/dist/esm/tools/annotation/PlanarFreehandROITool.d.ts

@@ -35,23 +35,23 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     _calculateStatsIfActive(annotation: PlanarFreehandROIAnnotation, targetId: string, viewport: any, renderingEngine: any, enabledElement: any): void;
     private _calculateCachedStats;
-    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, pixelValueUnits, canvasCoordinates, calibratedScale, }: {
+    protected updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }: {
         viewport: any;
         points: any;
         imageData: any;
         metadata: any;
         cachedStats: any;
         targetId: any;
-        pixelValueUnits: any;
+        modalityUnit: any;
         canvasCoordinates: any;
         calibratedScale: any;
     }): void;
-    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, pixelValueUnits, calibratedScale, }: {
+    protected updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }: {
         targetId: any;
         metadata: any;
         canvasCoordinates: any;
         cachedStats: any;
-        pixelValueUnits: any;
+        modalityUnit: any;
         calibratedScale: any;
     }): void;
     private _renderStats;