@cornerstonejs/tools 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/esm/config.d.ts

@@ -0,0 +1,29 @@
+import type { ContourSegmentationData } from './types';
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapSegmentationData } from './types/LabelmapTypes';
+import type { SurfaceSegmentationData } from './types/SurfaceTypes';
+export type PolySegConversionOptions = {
+    segmentIndices?: number[];
+    segmentationId?: string;
+    viewport?: Types.IStackViewport | Types.IVolumeViewport;
+};
+type ComputeRepresentationFn<T> = (segmentationId: string, options: PolySegConversionOptions) => Promise<T>;
+type PolySegAddOn = {
+    canComputeRequestedRepresentation: (segmentationId: string, representationType: string) => boolean;
+    init: () => void;
+    computeContourData: ComputeRepresentationFn<ContourSegmentationData>;
+    computeLabelmapData: ComputeRepresentationFn<LabelmapSegmentationData>;
+    computeSurfaceData: ComputeRepresentationFn<SurfaceSegmentationData>;
+    updateSurfaceData: ComputeRepresentationFn<SurfaceSegmentationData>;
+};
+type AddOns = {
+    polySeg: PolySegAddOn;
+};
+export type Config = {
+    addons: AddOns;
+};
+export declare function getConfig(): Config;
+export declare function setConfig(newConfig: Config): void;
+export declare function getAddOns(): AddOns;
+export declare function getPolySeg(): PolySegAddOn;
+export {};

package/dist/esm/config.js

@@ -0,0 +1,23 @@
+let config = {};
+export function getConfig() {
+    return config;
+}
+export function setConfig(newConfig) {
+    config = newConfig;
+}
+export function getAddOns() {
+    return config.addons;
+}
+let polysegInitialized = false;
+export function getPolySeg() {
+    if (!config.addons?.polySeg) {
+        console.warn('PolySeg add-on not configured. This will prevent automatic conversion between segmentation representations (labelmap, contour, surface). To enable these features, install @cornerstonejs/polymorphic-segmentation and register it during initialization: cornerstoneTools.init({ addons: { polySeg } }).');
+        return null;
+    }
+    const polyseg = config.addons.polySeg;
+    if (!polysegInitialized) {
+        polyseg.init();
+        polysegInitialized = true;
+    }
+    return polyseg;
+}

package/dist/esm/enums/StrategyCallbacks.d.ts

@@ -12,6 +12,8 @@ declare enum StrategyCallbacks {
     INTERNAL_setValue = "setValue",
     AddPreview = "addPreview",
     ComputeInnerCircleRadius = "computeInnerCircleRadius",
-    GetStatistics = "getStatistics"
+    GetStatistics = "getStatistics",
+    EnsureImageVolumeFor3DManipulation = "ensureImageVolumeFor3DManipulation",
+    EnsureSegmentationVolumeFor3DManipulation = "ensureSegmentationVolumeFor3DManipulation"
 }
 export default StrategyCallbacks;

package/dist/esm/enums/StrategyCallbacks.js

@@ -14,5 +14,7 @@ var StrategyCallbacks;
     StrategyCallbacks["AddPreview"] = "addPreview";
     StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
     StrategyCallbacks["GetStatistics"] = "getStatistics";
+    StrategyCallbacks["EnsureImageVolumeFor3DManipulation"] = "ensureImageVolumeFor3DManipulation";
+    StrategyCallbacks["EnsureSegmentationVolumeFor3DManipulation"] = "ensureSegmentationVolumeFor3DManipulation";
 })(StrategyCallbacks || (StrategyCallbacks = {}));
 export default StrategyCallbacks;

package/dist/esm/enums/WorkerTypes.d.ts

@@ -3,6 +3,8 @@ declare enum ChangeTypes {
     POLYSEG_SURFACE_TO_LABELMAP = "Converting Surfaces to Labelmap",
     POLYSEG_CONTOUR_TO_SURFACE = "Converting Contour to Surface",
     POLYSEG_LABELMAP_TO_SURFACE = "Converting Labelmap to Surface",
-    SURFACE_CLIPPING = "Clipping Surfaces"
+    SURFACE_CLIPPING = "Clipping Surfaces",
+    COMPUTE_STATISTICS = "Computing Statistics",
+    INTERPOLATE_LABELMAP = "Interpolating Labelmap"
 }
 export default ChangeTypes;

package/dist/esm/enums/WorkerTypes.js

@@ -5,5 +5,7 @@ var ChangeTypes;
     ChangeTypes["POLYSEG_CONTOUR_TO_SURFACE"] = "Converting Contour to Surface";
     ChangeTypes["POLYSEG_LABELMAP_TO_SURFACE"] = "Converting Labelmap to Surface";
     ChangeTypes["SURFACE_CLIPPING"] = "Clipping Surfaces";
+    ChangeTypes["COMPUTE_STATISTICS"] = "Computing Statistics";
+    ChangeTypes["INTERPOLATE_LABELMAP"] = "Interpolating Labelmap";
 })(ChangeTypes || (ChangeTypes = {}));
 export default ChangeTypes;

package/dist/esm/init.d.ts

@@ -1,3 +1,4 @@
-export declare function init(defaultConfiguration?: {}): void;
+import type { Config } from './config';
+export declare function init(defaultConfiguration?: Config): void;
 export declare function destroy(): void;
 export default init;

package/dist/esm/init.js

@@ -8,11 +8,13 @@ import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 import * as ToolGroupManager from './store/ToolGroupManager';
 import { defaultSegmentationStateManager } from './stateManagement/segmentation/SegmentationStateManager';
 import segmentationRepresentationModifiedListener from './eventListeners/segmentation/segmentationRepresentationModifiedListener';
+import { setConfig } from './config';
 let csToolsInitialized = false;
 export function init(defaultConfiguration = {}) {
     if (csToolsInitialized) {
         return;
     }
+    setConfig(defaultConfiguration);
     _addCornerstoneEventListeners();
     _addCornerstoneToolsEventListeners();
     csToolsInitialized = true;

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.js

@@ -51,7 +51,7 @@ function normalizeSegments(segmentsConfig, type, data) {
 }
 function normalizeSurfaceSegments(normalizedSegments, surfaceData) {
     const { geometryIds } = surfaceData;
-    geometryIds.forEach((geometryId) => {
+    geometryIds?.forEach((geometryId) => {
         const geometry = cache.getGeometry(geometryId);
         if (geometry?.data) {
             const { segmentIndex } = geometry.data;

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.js

@@ -1,5 +1,5 @@
 import * as Enums from '../../../enums';
-import { validatePublic as validatePublicLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
+import { validatePublic as validatePublicLabelmap } from '../../../utilities/segmentation/validateLabelmap';
 function validateSegmentationInput(segmentationInputArray) {
     if (!segmentationInputArray || segmentationInputArray.length === 0) {
         throw new Error('The segmentationInputArray is undefined or an empty array');

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

@@ -11,17 +11,18 @@ import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
 import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
-import * as polySegManager from './polySeg';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
 import { removeSegment } from './removeSegment';
 import { getLabelmapImageIds } from './getLabelmapImageIds';
 import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation } from './removeSegmentation';
+import { segmentationStyle } from './SegmentationStyle';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
 declare const helpers: {
     clearSegmentValue: typeof clearSegmentValue;
     convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };

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

@@ -11,17 +11,18 @@ import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import { convertStackToVolumeLabelmap } from './helpers/convertStackToVolumeLabelmap';
 import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapFromStack';
-import * as polySegManager from './polySeg';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
 import { removeSegment } from './removeSegment';
 import { getLabelmapImageIds } from './getLabelmapImageIds';
 import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation, } from './removeSegmentation';
+import { segmentationStyle } from './SegmentationStyle';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
 const helpers = {
     clearSegmentValue,
     convertStackToVolumeLabelmap,
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };

package/dist/esm/tools/displayTools/Contour/contourDisplay.js

@@ -2,9 +2,9 @@ import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
-import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
-import { computeAndAddContourRepresentation } from '../../../stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation';
 import removeContourFromElement from './removeContourFromElement';
+import { getPolySeg } from '../../../config';
+import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
 let polySegConversionInProgress = false;
 const processedViewportSegmentations = new Map();
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
@@ -27,14 +27,16 @@ async function render(viewport, contourRepresentation) {
     }
     let contourData = segmentation.representationData[Representations.Contour];
     if (!contourData &&
-        canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
+        getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
-        contourData = await computeAndAddContourRepresentation(segmentationId, {
-            viewport,
-        });
+        const polySeg = getPolySeg();
+        contourData = await computeAndAddRepresentation(segmentationId, Representations.Contour, () => polySeg.computeContourData(segmentationId, { viewport }), () => undefined);
         polySegConversionInProgress = false;
     }
+    else if (!contourData && !getPolySeg()) {
+        console.debug(`No contour data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to contour. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
     if (!contourData) {
         return;
     }

package/dist/esm/tools/displayTools/Labelmap/index.d.ts

@@ -1,4 +1,4 @@
 import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
-import { validate as validateLabelmap, validatePublic as validateLabelmapPublic } from './validateLabelmap';
+import { validate as validateLabelmap, validatePublic as validateLabelmapPublic } from '../../../utilities/segmentation/validateLabelmap';
 export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };

package/dist/esm/tools/displayTools/Labelmap/index.js

@@ -1,4 +1,4 @@
 import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
-import { validate as validateLabelmap, validatePublic as validateLabelmapPublic, } from './validateLabelmap';
+import { validate as validateLabelmap, validatePublic as validateLabelmapPublic, } from '../../../utilities/segmentation/validateLabelmap';
 export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -5,13 +5,15 @@ import { getActiveSegmentation } from '../../../stateManagement/segmentation/act
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
 import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
-import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
-import { computeAndAddLabelmapRepresentation } from '../../../stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation';
 import { segmentationStyle } from '../../../stateManagement/segmentation/SegmentationStyle';
 import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
 import { internalGetHiddenSegmentIndices } from '../../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
 import { getActiveSegmentIndex } from '../../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLabelmapActorEntry } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getPolySeg } from '../../../config';
+import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
+import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { defaultSegmentationStateManager } from '../../../stateManagement/segmentation/SegmentationStateManager';
 export const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
 let polySegConversionInProgress = false;
@@ -42,17 +44,24 @@ async function render(viewport, representation) {
     let labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
     let labelmapActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
     if (!labelmapData &&
-        canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
+        getPolySeg()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations.Labelmap) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
-        labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
-            viewport,
+        const polySeg = getPolySeg();
+        labelmapData = await computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => polySeg.computeLabelmapData(segmentationId, { viewport }), () => null, () => {
+            defaultSegmentationStateManager.processLabelmapRepresentationAddition(viewport.id, segmentationId);
+            setTimeout(() => {
+                triggerSegmentationDataModified(segmentationId);
+            }, 0);
         });
         if (!labelmapData) {
             throw new Error(`No labelmap data found for segmentationId ${segmentationId}.`);
         }
         polySegConversionInProgress = false;
     }
+    else if (!labelmapData && !getPolySeg()) {
+        console.debug(`No labelmap data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to labelmap. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
     if (!labelmapData) {
         return;
     }

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -4,9 +4,8 @@ import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
-import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
-import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation';
-const { ViewportType } = Enums;
+import { getPolySeg } from '../../../config';
+import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
@@ -27,14 +26,20 @@ async function render(viewport, representation) {
     }
     let SurfaceData = segmentation.representationData[Representations.Surface];
     if (!SurfaceData &&
-        canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
-        SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
-            viewport,
-        });
+        getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Surface)) {
+        const polySeg = getPolySeg();
+        SurfaceData = await computeAndAddRepresentation(segmentationId, Representations.Surface, () => polySeg.computeSurfaceData(segmentationId, { viewport }), () => polySeg.updateSurfaceData(segmentationId, { viewport }));
         if (!SurfaceData) {
-            throw new Error(`No Surface data found for segmentationId ${segmentationId}.`);
+            throw new Error(`No Surface data found for segmentationId ${segmentationId} even we tried to compute it`);
         }
     }
+    else if (!SurfaceData && !getPolySeg()) {
+        console.debug(`No surface data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to surface. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!SurfaceData) {
+        console.warn(`No Surface data found for segmentationId ${segmentationId}. Skipping render.`);
+        return;
+    }
     const { geometryIds } = SurfaceData;
     if (!geometryIds?.size) {
         console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);

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

@@ -22,14 +22,8 @@ class BrushTool extends LabelmapBaseTool {
                 THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
                 THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL: thresholdInsideSphereIsland,
             },
-            strategySpecificConfiguration: {
-                THRESHOLD: {
-                    threshold: [-150, -70],
-                },
-            },
             defaultStrategy: 'FILL_INSIDE_CIRCLE',
             activeStrategy: 'FILL_INSIDE_CIRCLE',
-            thresholdVolumeId: null,
             brushSize: 25,
             preview: {
                 enabled: false,
@@ -346,9 +340,7 @@ class BrushTool extends LabelmapBaseTool {
         drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
             color,
         });
-        const activeStrategy = this.configuration.activeStrategy;
-        const { dynamicRadiusInCanvas } = this.configuration
-            .strategySpecificConfiguration[activeStrategy] || {
+        const { dynamicRadiusInCanvas } = this.configuration?.threshold || {
             dynamicRadiusInCanvas: 0,
         };
         if (dynamicRadiusInCanvas) {

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

@@ -167,7 +167,6 @@ class CircleScissorsTool extends LabelmapBaseTool {
                 points: data.handles.points,
                 viewPlaneNormal,
                 viewUp,
-                strategySpecificConfiguration: {},
                 createMemo: this.createMemo.bind(this),
             };
             this.editData = null;

package/dist/esm/tools/segmentation/LabelmapBaseTool.d.ts

@@ -56,12 +56,11 @@ export default class LabelmapBaseTool extends BaseTool {
     protected get _previewData(): PreviewData;
     createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): LabelmapMemo.LabelmapMemo;
     protected createEditData(element: any): EditDataReturnType;
-    protected getEditData({ viewport, representationData, segmentsLocked, segmentationId, volumeOperation, }: {
+    protected getEditData({ viewport, representationData, segmentsLocked, segmentationId, }: {
         viewport: any;
         representationData: any;
         segmentsLocked: any;
         segmentationId: any;
-        volumeOperation?: boolean;
     }): EditDataReturnType;
     protected createHoverData(element: any, centerCanvas?: any): {
         brushCursor: {

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

@@ -1,4 +1,4 @@
-import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, volumeLoader, } from '@cornerstonejs/core';
+import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
@@ -6,7 +6,6 @@ import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segm
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { getClosestImageIdForStackViewport } from '../../utilities/annotationHydration';
 import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
-import { getStackSegmentationImageIdsForViewport } from '../../stateManagement/segmentation/getStackSegmentationImageIdsForViewport';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { StrategyCallbacks } from '../../enums';
@@ -61,7 +60,7 @@ export default class LabelmapBaseTool extends BaseTool {
         });
         return editData;
     }
-    getEditData({ viewport, representationData, segmentsLocked, segmentationId, volumeOperation = false, }) {
+    getEditData({ viewport, representationData, segmentsLocked, segmentationId, }) {
         if (viewport instanceof BaseVolumeViewport) {
             const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
             const actors = viewport.getActors();
@@ -82,7 +81,8 @@ export default class LabelmapBaseTool extends BaseTool {
             const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
             return {
                 volumeId,
-                referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
+                referencedVolumeId: this.configuration.threshold?.volumeId ??
+                    referencedVolumeIdToThreshold,
                 segmentsLocked,
             };
         }
@@ -91,50 +91,10 @@ export default class LabelmapBaseTool extends BaseTool {
             if (!segmentationImageId) {
                 return;
             }
-            if (this.configuration.activeStrategy.includes('SPHERE') ||
-                volumeOperation) {
-                const referencedImageIds = viewport.getImageIds();
-                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
-                if (!isValidVolumeForSphere) {
-                    throw new Error('Volume is not reconstructable for sphere manipulation');
-                }
-                const volumeId = `${segmentationId}_${viewport.id}`;
-                const volume = cache.getVolume(volumeId);
-                if (volume) {
-                    return {
-                        imageId: segmentationImageId,
-                        segmentsLocked,
-                        override: {
-                            voxelManager: volume.voxelManager,
-                            imageData: volume.imageData,
-                        },
-                    };
-                }
-                else {
-                    const { imageIds: labelmapImageIds } = representationData.Labelmap;
-                    if (!labelmapImageIds || labelmapImageIds.length === 1) {
-                        return {
-                            imageId: segmentationImageId,
-                            segmentsLocked,
-                        };
-                    }
-                    const volume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
-                    return {
-                        imageId: segmentationImageId,
-                        segmentsLocked,
-                        override: {
-                            voxelManager: volume.voxelManager,
-                            imageData: volume.imageData,
-                        },
-                    };
-                }
-            }
-            else {
-                return {
-                    imageId: segmentationImageId,
-                    segmentsLocked,
-                };
-            }
+            return {
+                imageId: segmentationImageId,
+                segmentsLocked,
+            };
         }
     }
     createHoverData(element, centerCanvas) {
@@ -199,7 +159,8 @@ export default class LabelmapBaseTool extends BaseTool {
             toolGroupId: this.toolGroupId,
             segmentationId,
             viewUp,
-            strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
+            activeStrategy: this.configuration.activeStrategy,
+            configuration: this.configuration,
             preview: this._previewData?.preview,
             createMemo: this.createMemo.bind(this),
         };

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

@@ -172,7 +172,6 @@ class RectangleScissorsTool extends LabelmapBaseTool {
             const operationData = {
                 ...this.editData,
                 points: data.handles.points,
-                strategySpecificConfiguration: {},
                 createMemo: this.createMemo.bind(this),
             };
             this.editData = null;

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

@@ -92,7 +92,6 @@ class SphereScissorsTool extends LabelmapBaseTool {
                 representationData,
                 segmentsLocked,
                 segmentationId,
-                volumeOperation: true,
             });
             this.editData = {
                 ...this.editData,

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -17,7 +17,19 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     previewVoxelManager: Types.IVoxelManager<number>;
     previewSegmentIndex?: number;
     brushStrategy: BrushStrategy;
-    configuration?: Record<string, any>;
+    activeStrategy: string;
+    configuration?: {
+        [key: string]: unknown;
+        centerSegmentIndex?: {
+            segmentIndex: number;
+        };
+        threshold?: {
+            range?: number[];
+            isDynamic: boolean;
+            dynamicRadius: number;
+            dynamicRadiusInCanvas?: number;
+        };
+    };
     memo?: LabelmapMemo;
 };
 export type StrategyFunction = (operationData: InitializedOperationData, ...args: any[]) => unknown;
@@ -64,16 +76,13 @@ export default class BrushStrategy {
         labelmapStatistics: {
             getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
                 indices?: number | number[];
-            }) => import("../../../types").NamedStatistics;
+            }) => void;
+        };
+        ensureSegmentationVolumeFor3DManipulation: {
+            ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
         };
-        labelmapInterpolation: {
-            interpolate: (operationData: InitializedOperationData, configuration: {
-                label?: number;
-                axis?: number;
-                noHeuristicAlignment?: boolean;
-                noUseDistanceTransform?: boolean;
-                useCustomSlicePositions?: boolean;
-            }) => Promise<InitializedOperationData>;
+        ensureImageVolumeFor3DManipulation: {
+            ensureImageVolumeFor3DManipulation: (data: any) => void;
         };
     };
     protected static childFunctions: {
@@ -88,6 +97,8 @@ export default class BrushStrategy {
         setValue: (brushStrategy: any, func: any) => void;
         preview: (brushStrategy: any, func: any) => void;
         computeInnerCircleRadius: (brushStrategy: any, func: any) => void;
+        ensureSegmentationVolumeFor3DManipulation: (brushStrategy: any, func: any) => void;
+        ensureImageVolumeFor3DManipulation: (brushStrategy: any, func: any) => void;
         addPreview: (brushStrategy: any, func: any) => void;
         getStatistics: (brushStrategy: any, func: any) => void;
         compositions: any;

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

@@ -18,6 +18,8 @@ export default class BrushStrategy {
         [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
         [StrategyCallbacks.Preview]: addSingletonMethod(StrategyCallbacks.Preview, false),
         [StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(StrategyCallbacks.ComputeInnerCircleRadius),
+        [StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation),
+        [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
         [StrategyCallbacks.AddPreview]: addListMethod(StrategyCallbacks.AddPreview),
         [StrategyCallbacks.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
         compositions: null,
@@ -31,12 +33,12 @@ export default class BrushStrategy {
             if (!initializedData) {
                 return;
             }
-            const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
-            if (csUtils.isEqual(centerIJK, strategySpecificConfiguration.centerIJK)) {
+            const { configuration = {}, centerIJK } = initializedData;
+            if (csUtils.isEqual(centerIJK, configuration.centerIJK)) {
                 return operationData.preview;
             }
             else {
-                strategySpecificConfiguration.centerIJK = centerIJK;
+                configuration.centerIJK = centerIJK;
             }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, segmentIndex, } = initializedData;
@@ -90,14 +92,12 @@ export default class BrushStrategy {
     }
     initialize(enabledElement, operationData, operationName) {
         const { viewport } = enabledElement;
-        const data = getStrategyData({ operationData, viewport });
+        const data = getStrategyData({ operationData, viewport, strategy: this });
         if (!data) {
             console.warn('No data found for 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.createRLEHistoryVoxelManager(segmentationVoxelManager);
         const previewEnabled = !!operationData.previewColors;
@@ -108,8 +108,8 @@ export default class BrushStrategy {
             ...operationData,
             enabledElement,
             imageVoxelManager,
-            segmentationVoxelManager: segmentationVoxelManagerToUse,
-            segmentationImageData: segmentationImageDataToUse,
+            segmentationVoxelManager,
+            segmentationImageData,
             previewVoxelManager,
             viewport,
             centerWorld: null,

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

@@ -1,21 +1,18 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { strategySpecificConfiguration } = operationData;
-        if (!strategySpecificConfiguration) {
+        const { centerSegmentIndex } = operationData.configuration || {};
+        if (!centerSegmentIndex) {
             return;
         }
-        const { centerSegmentIndex } = strategySpecificConfiguration;
-        if (centerSegmentIndex) {
-            operationData.segmentIndex = centerSegmentIndex.segmentIndex;
-        }
+        operationData.segmentIndex = centerSegmentIndex.segmentIndex;
     },
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, strategySpecificConfiguration, viewPlaneNormal, segmentationImageData, preview, } = operationData;
-        if (!strategySpecificConfiguration?.useCenterSegmentIndex) {
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, preview, configuration, } = operationData;
+        if (!configuration?.useCenterSegmentIndex) {
             return;
         }
-        delete strategySpecificConfiguration.centerSegmentIndex;
+        delete configuration.centerSegmentIndex;
         let hasSegmentIndex = false;
         let hasPreviewIndex = false;
         const nestedBounds = [
@@ -55,7 +52,7 @@ export default {
             existingValue = null;
         }
         operationData.segmentIndex = existingValue;
-        strategySpecificConfiguration.centerSegmentIndex = {
+        configuration.centerSegmentIndex = {
             segmentIndex: existingValue,
         };
     },