@cornerstonejs/tools 2.0.0-beta.23 → 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/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/segmentation/BrushTool.d.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
 import { BaseTool } from '../base';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export type PreviewData = {
     preview: unknown;
     timer?: number;
@@ -24,11 +25,22 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
     } | {
         imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;
         referencedVolumeId?: undefined;
+        override?: undefined;
+    } | {
+        imageId: string;
+        segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
     };
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
@@ -48,8 +60,13 @@ declare class BrushTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
         segmentsLocked: number[];
         imageId?: string;
+        imageIds?: string[];
         volumeId?: string;
         referencedVolumeId?: string;
     } | {
@@ -67,6 +84,23 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        segmentationRepresentationUID: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageId: string;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+        override?: undefined;
     } | {
         points: any;
         segmentIndex: number;
@@ -80,6 +114,10 @@ declare class BrushTool extends BaseTool {
         preview: unknown;
         imageId: string;
         segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
         volumeId?: undefined;
         referencedVolumeId?: undefined;
     };

package/dist/esm/tools/segmentation/BrushTool.js

@@ -10,10 +10,11 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -141,7 +142,6 @@ class BrushTool extends BaseTool {
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
             triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
@@ -235,12 +235,45 @@ class BrushTool extends BaseTool {
                 return;
             }
             if (this.configuration.activeStrategy.includes('SPHERE')) {
-                throw new Error('Sphere manipulation is not supported for stacks of image segmentations yet');
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
+                if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                    };
+                }
+                const tempVolumeId = 'tempVolumeId';
+                const { dimensions, direction, origin, spacing, numberOfComponents, imageIds: sortedLabelmapImageIds, } = csUtils.generateVolumePropsFromImageIds(labelmapImageIds, tempVolumeId);
+                const newVoxelManager = csUtils.VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds: sortedLabelmapImageIds,
+                    numberOfComponents,
+                });
+                const newImageData = vtkImageData.newInstance();
+                newImageData.setDimensions(dimensions);
+                newImageData.setSpacing(spacing);
+                newImageData.setDirection(direction);
+                newImageData.setOrigin(origin);
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                    override: {
+                        voxelManager: newVoxelManager,
+                        imageData: newImageData,
+                    },
+                };
+            }
+            else {
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
             }
-            return {
-                imageId: segmentationImageId,
-                segmentsLocked,
-            };
         }
     }
     createHoverData(element, centerCanvas) {

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -37,7 +37,8 @@ export default class BrushStrategy {
             }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfSlices());
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
+            segmentationVoxelManager.resetModifiedSlices();
             if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
                 return null;
             }
@@ -69,7 +70,9 @@ export default class BrushStrategy {
                 BrushStrategy.childFunctions[key](this, result[key]);
             }
         });
-        this.strategyFunction = (enabledElement, operationData) => this.fill(enabledElement, operationData);
+        this.strategyFunction = (enabledElement, operationData) => {
+            return this.fill(enabledElement, operationData);
+        };
         for (const key of Object.keys(BrushStrategy.childFunctions)) {
             this.strategyFunction[key] = this[key];
         }
@@ -82,9 +85,11 @@ export default class BrushStrategy {
             return operationData.preview;
         }
         const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
+        const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
+        const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
             VoxelManager.createHistoryVoxelManager({
-                sourceVoxelManager: segmentationVoxelManager,
+                sourceVoxelManager: segmentationVoxelManagerToUse,
             });
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
@@ -94,8 +99,8 @@ export default class BrushStrategy {
             ...operationData,
             enabledElement,
             imageVoxelManager,
-            segmentationVoxelManager,
-            segmentationImageData,
+            segmentationVoxelManager: segmentationVoxelManagerToUse,
+            segmentationImageData: segmentationImageDataToUse,
             previewVoxelManager,
             viewport,
             centerWorld: null,

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -118,6 +118,6 @@ export default {
                 }
             }
         }
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -66,7 +66,7 @@ export default {
             }
         };
         tracking.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
         tracking.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
@@ -78,7 +78,7 @@ export default {
             segmentationVoxelManager.setAtIndex(index, value);
         };
         previewVoxelManager.forEach(callback);
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
         previewVoxelManager.clear();
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/setValue.js

@@ -1,12 +1,14 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
+        let changed = false;
         if (segmentIndex === null) {
             const oldValue = previewVoxelManager.getAtIndex(index);
             if (oldValue !== undefined) {
-                previewVoxelManager.setAtIndex(index, oldValue);
+                changed = previewVoxelManager.setAtIndex(index, oldValue);
             }
             return;
         }
@@ -15,13 +17,13 @@ export default {
         }
         if (existingValue === previewSegmentIndex) {
             if (previewVoxelManager.getAtIndex(index) === undefined) {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+                changed = segmentationVoxelManager.setAtIndex(index, segmentIndex);
             }
             else {
                 return;
             }
         }
         const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
-        previewVoxelManager.setAtIndex(index, useSegmentIndex);
+        changed = previewVoxelManager.setAtIndex(index, useSegmentIndex);
     },
 };

package/dist/esm/tools/segmentation/strategies/fillSphere.js

@@ -21,20 +21,11 @@ const sphereComposition = {
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfo(points.slice(0, 2), segmentationImageData, viewport);
         segmentationVoxelManager.boundsIJK = newBoundsIJK;
-        if (imageVoxelManager) {
-            imageVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
-        else {
-            segmentationVoxelManager.isInObject = createEllipseInPoint({
-                topLeftWorld,
-                bottomRightWorld,
-                center,
-            });
-        }
+        segmentationVoxelManager.isInObject = createEllipseInPoint({
+            topLeftWorld,
+            bottomRightWorld,
+            center,
+        });
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview);

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
@@ -11,6 +12,10 @@ type LabelmapToolOperationData = {
     segmentationRepresentationUID: string;
     points: Types.Point3[];
     voxelManager: any;
+    override: {
+        voxelManager: Types.IVoxelManager<number>;
+        imageData: vtkImageData;
+    };
     preview: any;
     toolGroupId: string;
 };

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -15,13 +15,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         return;
     }
     const numSlices = vol.dimensions[2];
-    const segData = vol.imageData.getPointData().getScalars().getData();
+    const voxelManager = vol.voxelManager;
     const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
     for (let z = 0; z < numSlices; z++) {
         for (let y = 0; y < vol.dimensions[1]; y++) {
             const index = y * vol.dimensions[0] + z * pixelsPerSlice;
-            segData[index] = 0;
-            segData[index + vol.dimensions[0] - 1] = 0;
+            voxelManager.setAtIndex(index, 0);
+            voxelManager.setAtIndex(index + vol.dimensions[0] - 1, 0);
         }
     }
     const ContourSets = [];
@@ -41,13 +41,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         });
         const { containedSegmentIndices } = segment;
         for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
-            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+            if (isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex)) {
                 continue;
             }
             const frameStart = sliceIndex * pixelsPerSlice;
             try {
                 for (let i = 0; i < pixelsPerSlice; i++) {
-                    const value = segData[i + frameStart];
+                    const value = voxelManager.getAtIndex(i + frameStart);
                     if (value === segIndex || containedSegmentIndices?.has(value)) {
                         scalars.setValue(i + frameStart, 1);
                     }
@@ -96,11 +96,11 @@ function generateContourSetsFromLabelmap({ segmentations }) {
     }
     return ContourSets;
 }
-function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+function isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex) {
     const startIdx = sliceIndex * pixelsPerSlice;
     const endIdx = startIdx + pixelsPerSlice;
     for (let i = startIdx; i < endIdx; i++) {
-        if (segData[i] === segIndex) {
+        if (voxelManager.getAtIndex(i) === segIndex) {
             return false;
         }
     }

package/dist/esm/utilities/segmentation/getSegmentIndexAtLabelmapBorder.js

@@ -4,14 +4,16 @@ import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
     const labelmapData = segmentation.representationData.LABELMAP;
-    if (isVolumeSegmentation(labelmapData)) {
+    if (isVolumeSegmentation(labelmapData, viewport)) {
         const { volumeId } = labelmapData;
         const segmentationVolume = cache.getVolume(volumeId);
         if (!segmentationVolume) {
             return;
         }
+        const voxelManager = segmentationVolume.voxelManager;
         const imageData = segmentationVolume.imageData;
-        const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        const segmentIndex = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
         const canvasPoint = viewport.worldToCanvas(worldPoint);
         const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
         return onEdge ? segmentIndex : undefined;
@@ -69,7 +71,9 @@ function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, s
     const getNeighborIndex = (deltaI, deltaJ) => {
         const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
         const worldPoint = viewport.canvasToWorld(neighborCanvas);
-        return imageData.getScalarValueFromWorld(worldPoint);
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        return voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
     };
     return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
 }

package/dist/esm/utilities/segmentation/isLineInSegment.js

@@ -25,7 +25,7 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
         console.warn(`No volume found for ${segVolumeId}`);
         return;
     }
-    const segData = vol.imageData.getPointData().getScalars().getData();
+    const voxelManager = vol.voxelManager;
     const width = vol.dimensions[0];
     const pixelsPerSlice = width * vol.dimensions[1];
     return {
@@ -34,14 +34,14 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
             const ijk = vol.imageData.worldToIndex(point).map(Math.round);
             const [i, j, k] = ijk;
             const index = i + j * width + k * pixelsPerSlice;
-            const value = segData[index];
+            const value = voxelManager.getAtIndex(index);
             return value === segmentIndex || containedSegmentIndices?.has(value);
         },
         toIJK: (point) => vol.imageData.worldToIndex(point),
         testIJK: (ijk) => {
             const [i, j, k] = ijk;
             const index = Math.round(i) + Math.round(j) * width + Math.round(k) * pixelsPerSlice;
-            const value = segData[index];
+            const value = voxelManager.getAtIndex(index);
             return value === segmentIndex || containedSegmentIndices?.has(value);
         },
     };