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

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

@@ -2,9 +2,8 @@ import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, viewport, } = operationData;
-        const { THRESHOLD } = strategySpecificConfiguration;
-        if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
+        const { operationName, centerIJK, segmentationVoxelManager, imageVoxelManager, configuration, segmentIndex, viewport, } = operationData;
+        if (!configuration?.threshold?.isDynamic || !centerIJK || !segmentIndex) {
             return;
         }
         if (operationName === StrategyCallbacks.RejectPreview ||
@@ -12,7 +11,7 @@ export default {
             return;
         }
         const boundsIJK = segmentationVoxelManager.getBoundsIJK();
-        const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
+        const { range: oldThreshold, dynamicRadius = 0 } = configuration.threshold;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
         const { viewPlaneNormal } = viewport.getCamera();
         const nestedBounds = boundsIJK.map((ijk, idx) => {
@@ -43,18 +42,22 @@ export default {
             threshold[1] = Math.max(gray, threshold[1]);
         };
         imageVoxelManager.forEach(callback, { boundsIJK: nestedBounds });
-        operationData.strategySpecificConfiguration.THRESHOLD.threshold = threshold;
+        configuration.threshold.range = threshold;
     },
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { strategySpecificConfiguration, preview } = operationData;
-        if (!strategySpecificConfiguration?.THRESHOLD?.isDynamic && !preview) {
+        const { configuration } = operationData;
+        if (!configuration?.threshold?.isDynamic) {
             return;
         }
-        strategySpecificConfiguration.THRESHOLD.threshold = null;
+        configuration.threshold.range = null;
     },
     [StrategyCallbacks.ComputeInnerCircleRadius]: (operationData) => {
         const { configuration, viewport } = operationData;
-        const { THRESHOLD: { dynamicRadius = 0 } = {} } = configuration.strategySpecificConfiguration || {};
+        const { dynamicRadius = 0, isDynamic } = configuration.threshold;
+        if (!isDynamic) {
+            configuration.threshold.dynamicRadiusInCanvas = 0;
+            return;
+        }
         if (dynamicRadius === 0) {
             return;
         }
@@ -72,11 +75,9 @@ export default {
         const offSetCenterInWorld = centerCursorInWorld.map((coord) => coord + radiusInWorld);
         const offSetCenterCanvas = viewport.worldToCanvas(offSetCenterInWorld);
         const dynamicRadiusInCanvas = Math.abs(centerCanvas[0] - offSetCenterCanvas[0]);
-        const { strategySpecificConfiguration, activeStrategy } = configuration;
-        if (!strategySpecificConfiguration[activeStrategy]) {
-            strategySpecificConfiguration[activeStrategy] = {};
+        if (!configuration.threshold.dynamicRadiusInCanvas) {
+            configuration.threshold.dynamicRadiusInCanvas = 0;
         }
-        strategySpecificConfiguration[activeStrategy].dynamicRadiusInCanvas =
-            3 + dynamicRadiusInCanvas;
+        configuration.threshold.dynamicRadiusInCanvas = 3 + dynamicRadiusInCanvas;
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/ensureImageVolume.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    ensureImageVolumeFor3DManipulation: (data: any) => void;
+};
+export default _default;

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

@@ -0,0 +1,35 @@
+import { cache, utilities as csUtils, volumeLoader } from '@cornerstonejs/core';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+export default {
+    [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: (data) => {
+        const { operationData, viewport } = data;
+        let referencedImageIds;
+        if (viewport) {
+            const referencedImageIds = viewport.getImageIds();
+            const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+            if (!isValidVolumeForSphere) {
+                throw new Error('Volume is not reconstructable for sphere manipulation');
+            }
+        }
+        else {
+            const segmentation = getSegmentation(operationData.segmentationId);
+            const imageIds = segmentation.representationData
+                .Labelmap.imageIds;
+            referencedImageIds = imageIds.map((imageId) => {
+                const image = cache.getImage(imageId);
+                return image.referencedImageId;
+            });
+        }
+        const volumeId = cache.generateVolumeId(referencedImageIds);
+        let imageVolume = cache.getVolume(volumeId);
+        if (imageVolume) {
+            operationData.imageVoxelManager = imageVolume.voxelManager;
+            operationData.imageData = imageVolume.imageData;
+            return;
+        }
+        imageVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds);
+        operationData.imageVoxelManager = imageVolume.voxelManager;
+        operationData.imageData = imageVolume.imageData;
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/ensureSegmentationVolume.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
+};
+export default _default;

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

@@ -0,0 +1,20 @@
+import { utilities, cache } from '@cornerstonejs/core';
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import getOrCreateSegmentationVolume from '../../../../utilities/segmentation/getOrCreateSegmentationVolume';
+export default {
+    [StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: (data) => {
+        const { operationData, viewport } = data;
+        const { segmentationId, imageIds: segImageIds } = operationData;
+        const referencedImageIds = viewport
+            ? viewport.getImageIds()
+            : segImageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
+        const isValidVolumeForSphere = utilities.isValidVolume(referencedImageIds);
+        if (!isValidVolumeForSphere) {
+            throw new Error('Volume is not reconstructable for sphere manipulation');
+        }
+        const segVolume = getOrCreateSegmentationVolume(segmentationId);
+        operationData.segmentationVoxelManager = segVolume.voxelManager;
+        operationData.segmentationImageData = segVolume.imageData;
+        return;
+    },
+};

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -35,16 +35,13 @@ declare const _default: {
     labelmapStatistics: {
         getStatistics: (enabledElement: any, operationData: import("../BrushStrategy").InitializedOperationData, options?: {
             indices?: number | number[];
-        }) => import("../../../../types").NamedStatistics;
-    };
-    labelmapInterpolation: {
-        interpolate: (operationData: import("../BrushStrategy").InitializedOperationData, configuration: {
-            label?: number;
-            axis?: number;
-            noHeuristicAlignment?: boolean;
-            noUseDistanceTransform?: boolean;
-            useCustomSlicePositions?: boolean;
-        }) => Promise<import("../BrushStrategy").InitializedOperationData>;
+        }) => void;
+    };
+    ensureSegmentationVolumeFor3DManipulation: {
+        ensureSegmentationVolumeFor3DManipulation: (data: any) => void;
+    };
+    ensureImageVolumeFor3DManipulation: {
+        ensureImageVolumeFor3DManipulation: (data: any) => void;
     };
 };
 export default _default;

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

@@ -7,7 +7,8 @@ import regionFill from './regionFill';
 import setValue from './setValue';
 import threshold from './threshold';
 import labelmapStatistics from './labelmapStatistics';
-import labelmapInterpolation from './labelmapInterpolation';
+import ensureSegmentationVolumeFor3DManipulation from './ensureSegmentationVolume';
+import ensureImageVolumeFor3DManipulation from './ensureImageVolume';
 export default {
     determineSegmentIndex,
     dynamicThreshold,
@@ -18,5 +19,6 @@ export default {
     setValue,
     threshold,
     labelmapStatistics,
-    labelmapInterpolation,
+    ensureSegmentationVolumeFor3DManipulation,
+    ensureImageVolumeFor3DManipulation,
 };

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

@@ -3,8 +3,9 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
 export default {
     [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
-        const { strategySpecificConfiguration, previewSegmentIndex, segmentIndex, viewport, previewVoxelManager, segmentationVoxelManager, } = operationData;
-        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+        const { previewSegmentIndex, segmentIndex, viewport, previewVoxelManager, segmentationVoxelManager, activeStrategy, } = operationData;
+        if (activeStrategy !== 'THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL' ||
+            segmentIndex === null) {
             return;
         }
         const islandRemoval = new IslandRemoval();

package/dist/esm/tools/segmentation/strategies/compositions/labelmapStatistics.d.ts

@@ -2,6 +2,6 @@ import type { InitializedOperationData } from '../BrushStrategy';
 declare const _default: {
     getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
         indices?: number | number[];
-    }) => import("../../../../types").NamedStatistics;
+    }) => void;
 };
 export default _default;

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

@@ -1,103 +1,12 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import VolumetricCalculator from '../../../../utilities/segmentation/VolumetricCalculator';
-import { getActiveSegmentIndex } from '../../../../stateManagement/segmentation/getActiveSegmentIndex';
-import { getStrategyData } from '../utils/getStrategyData';
-import { utilities } from '@cornerstonejs/core';
-import { getPixelValueUnits } from '../../../../utilities/getPixelValueUnits';
-import { AnnotationTool } from '../../../base';
-import { isViewportPreScaled } from '../../../../utilities/viewport/isViewportPreScaled';
-const radiusForVol1 = Math.pow((3 * 1000) / (4 * Math.PI), 1 / 3);
+import getStatistics from '../../../../utilities/segmentation/getStatistics';
 export default {
     [StrategyCallbacks.GetStatistics]: function (enabledElement, operationData, options) {
-        const { viewport } = enabledElement;
-        let { indices } = options;
-        const { segmentationId } = operationData;
-        if (!indices) {
-            indices = [getActiveSegmentIndex(segmentationId)];
-        }
-        else if (!Array.isArray(indices)) {
-            indices = [indices, 255];
-        }
-        const indicesArr = indices;
-        const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, } = getStrategyData({
-            operationData,
-            viewport,
+        const { indices } = options;
+        const { segmentationId, viewport } = operationData;
+        getStatistics({
+            segmentationId,
+            segmentIndices: indices,
         });
-        const spacing = segmentationImageData.getSpacing();
-        const { boundsIJK: boundsOrig } = segmentationVoxelManager;
-        if (!boundsOrig) {
-            return VolumetricCalculator.getStatistics({ spacing });
-        }
-        segmentationVoxelManager.forEach((voxel) => {
-            const { value, pointIJK } = voxel;
-            if (indicesArr.indexOf(value) === -1) {
-                return;
-            }
-            const imageValue = imageVoxelManager.getAtIJKPoint(pointIJK);
-            VolumetricCalculator.statsCallback({ value: imageValue, pointIJK });
-        });
-        const targetId = viewport.getViewReferenceId();
-        const modalityUnitOptions = {
-            isPreScaled: isViewportPreScaled(viewport, targetId),
-            isSuvScaled: AnnotationTool.isSuvScaled(viewport, targetId, viewport.getCurrentImageId()),
-        };
-        const imageData = viewport.getImageData();
-        const unit = getPixelValueUnits(imageData.metadata.Modality, viewport.getCurrentImageId(), modalityUnitOptions);
-        const stats = VolumetricCalculator.getStatistics({ spacing, unit });
-        const { maxIJKs } = stats;
-        if (!maxIJKs?.length) {
-            return stats;
-        }
-        stats.mean.unit = unit;
-        stats.max.unit = unit;
-        stats.min.unit = unit;
-        if (unit !== 'SUV') {
-            return stats;
-        }
-        const radiusIJK = spacing.map((s) => Math.max(1, Math.round((1.1 * radiusForVol1) / s)));
-        for (const testMax of maxIJKs) {
-            const testStats = getSphereStats(testMax, radiusIJK, segmentationImageData, imageVoxelManager, spacing);
-            if (!testStats) {
-                continue;
-            }
-            const { mean } = testStats;
-            if (!stats.peakValue || stats.peakValue.value <= mean.value) {
-                stats.peakValue = {
-                    name: 'peakValue',
-                    label: 'Peak Value',
-                    value: mean.value,
-                    unit,
-                };
-            }
-        }
-        return stats;
     },
 };
-function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
-    const { pointIJK: centerIJK } = testMax;
-    const boundsIJK = centerIJK.map((ijk, idx) => [
-        ijk - radiusIJK[idx],
-        ijk + radiusIJK[idx],
-    ]);
-    const testFunction = (_pointLPS, pointIJK) => {
-        const i = (pointIJK[0] - centerIJK[0]) / radiusIJK[0];
-        const j = (pointIJK[1] - centerIJK[1]) / radiusIJK[1];
-        const k = (pointIJK[2] - centerIJK[2]) / radiusIJK[2];
-        const radius = i * i + j * j + k * k;
-        return radius <= 1;
-    };
-    const statsFunction = ({ pointIJK, pointLPS }) => {
-        const value = imageVoxels.getAtIJKPoint(pointIJK);
-        if (value === undefined) {
-            return;
-        }
-        VolumetricCalculator.statsCallback({ value, pointLPS, pointIJK });
-    };
-    VolumetricCalculator.statsInit({ storePointData: false });
-    utilities.pointInShapeCallback(segData, {
-        pointInShapeFn: testFunction,
-        callback: statsFunction,
-        boundsIJK,
-    });
-    return VolumetricCalculator.getStatistics({ spacing });
-}

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

@@ -12,14 +12,14 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 }
 export default {
     [StrategyCallbacks.Preview]: function (operationData) {
-        const { previewColors, strategySpecificConfiguration, enabledElement } = operationData;
-        if (!previewColors || !strategySpecificConfiguration) {
+        const { previewColors, configuration, enabledElement } = operationData;
+        if (!previewColors || !configuration) {
             return;
         }
         if (operationData.preview) {
             delete operationData.preview;
         }
-        delete strategySpecificConfiguration.centerSegmentIndex;
+        delete configuration.centerSegmentIndex;
         this.onInteractionStart?.(enabledElement, operationData);
         const preview = this.fill(enabledElement, operationData);
         if (preview) {

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

@@ -2,21 +2,20 @@ import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.CreateIsInThreshold]: (operationData) => {
-        const { imageVoxelManager, strategySpecificConfiguration, segmentIndex } = operationData;
-        if (!strategySpecificConfiguration || !segmentIndex) {
+        const { imageVoxelManager, segmentIndex, configuration } = operationData;
+        if (!configuration || !segmentIndex) {
             return;
         }
         return (index) => {
-            const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
             const voxelValue = imageVoxelManager.getAtIndex(index);
             const gray = Array.isArray(voxelValue)
                 ? vec3.length(voxelValue)
                 : voxelValue;
-            const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE || {};
-            if (!threshold?.length) {
+            const { threshold } = configuration || {};
+            if (!threshold?.range?.length) {
                 return true;
             }
-            return threshold[0] <= gray && gray <= threshold[1];
+            return threshold.range[0] <= gray && gray <= threshold.range[1];
         };
     },
 };

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

@@ -61,8 +61,8 @@ function createPointInEllipse(worldInfo) {
     const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
     return precalculated;
 }
-const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.labelmapInterpolation);
-const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics, compositions.labelmapInterpolation);
+const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
 const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 export function fillOutsideCircle() {

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

@@ -28,10 +28,10 @@ const sphereComposition = {
         });
     },
 };
-const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.ensureSegmentationVolumeFor3DManipulation);
 const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
-const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold);
-const SPHERE_THRESHOLD_STRATEGY_ISLAND = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
+const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.ensureSegmentationVolumeFor3DManipulation, compositions.ensureImageVolumeFor3DManipulation);
+const SPHERE_THRESHOLD_STRATEGY_ISLAND = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval, compositions.ensureSegmentationVolumeFor3DManipulation, compositions.ensureImageVolumeFor3DManipulation);
 const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
 const thresholdInsideSphereIsland = SPHERE_THRESHOLD_STRATEGY_ISLAND.strategyFunction;
 export function fillOutsideSphere() {

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.d.ts

@@ -1,11 +1,15 @@
-declare function getStrategyData({ operationData, viewport }: {
-    operationData: any;
-    viewport: any;
+import { type Types } from '@cornerstonejs/core';
+import type { LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume } from '../../../../types';
+declare function getStrategyData({ operationData, viewport, strategy, }: {
+    operationData: LabelmapToolOperationDataStack | LabelmapToolOperationDataVolume;
+    viewport?: Types.IStackViewport | Types.IVolumeViewport;
+    strategy: unknown;
 }): {
     segmentationImageData: any;
     segmentationScalarData: any;
     imageScalarData: any;
     segmentationVoxelManager: any;
     imageVoxelManager: any;
+    imageData: any;
 };
 export { getStrategyData };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -1,47 +1,67 @@
 import { BaseVolumeViewport, cache, Enums, eventTarget, } from '@cornerstonejs/core';
 import { getCurrentLabelmapImageIdForViewport } from '../../../../stateManagement/segmentation/segmentationState';
 import { getLabelmapActorEntry } from '../../../../stateManagement/segmentation/helpers';
-function getStrategyData({ operationData, viewport }) {
-    let segmentationImageData, segmentationScalarData, imageScalarData;
+function getStrategyDataForVolumeViewport({ operationData }) {
+    const { volumeId } = operationData;
+    if (!volumeId) {
+        const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message: 'No volume id found for the segmentation',
+            },
+            cancelable: true,
+        });
+        eventTarget.dispatchEvent(event);
+        return null;
+    }
+    const segmentationVolume = cache.getVolume(volumeId);
+    if (!segmentationVolume) {
+        return null;
+    }
+    const referencedVolumeId = segmentationVolume.referencedVolumeId;
+    const segmentationVoxelManager = segmentationVolume.voxelManager;
     let imageVoxelManager;
+    let imageData;
+    if (referencedVolumeId) {
+        const imageVolume = cache.getVolume(referencedVolumeId);
+        imageVoxelManager = imageVolume.voxelManager;
+        imageData = imageVolume.imageData;
+    }
+    const { imageData: segmentationImageData } = segmentationVolume;
+    return {
+        segmentationImageData,
+        segmentationVoxelManager,
+        segmentationScalarData: null,
+        imageScalarData: null,
+        imageVoxelManager,
+        imageData,
+    };
+}
+function getStrategyDataForStackViewport({ operationData, viewport, strategy, }) {
+    const { segmentationId } = operationData;
+    let segmentationImageData;
     let segmentationVoxelManager;
-    if (viewport instanceof BaseVolumeViewport) {
-        const { volumeId, referencedVolumeId } = operationData;
-        if (!volumeId) {
-            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
-                detail: {
-                    type: 'Segmentation',
-                    message: 'No volume id found for the segmentation',
-                },
-                cancelable: true,
-            });
-            eventTarget.dispatchEvent(event);
-            return null;
-        }
-        const segmentationVolume = cache.getVolume(volumeId);
-        if (!segmentationVolume) {
-            return;
-        }
-        segmentationVoxelManager = segmentationVolume.voxelManager;
-        if (referencedVolumeId) {
-            const imageVolume = cache.getVolume(referencedVolumeId);
-            imageVoxelManager = imageVolume.voxelManager;
-        }
-        ({ imageData: segmentationImageData } = segmentationVolume);
+    let segmentationScalarData;
+    let imageScalarData;
+    let imageVoxelManager;
+    let imageData;
+    if (strategy.ensureSegmentationVolumeFor3DManipulation) {
+        strategy.ensureSegmentationVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        segmentationVoxelManager = operationData.segmentationVoxelManager;
+        segmentationImageData = operationData.segmentationImageData;
+        segmentationScalarData = null;
     }
     else {
-        const { segmentationId } = operationData;
         const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
-            return;
-        }
-        const currentImageId = viewport.getCurrentImageId();
-        if (!currentImageId) {
-            return;
+            return null;
         }
         const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
         if (!actorEntry) {
-            return;
+            return null;
         }
         const currentSegImage = cache.getImage(labelmapImageId);
         segmentationImageData = actorEntry.actor.getMapper().getInputData();
@@ -49,11 +69,26 @@ function getStrategyData({ operationData, viewport }) {
         const currentSegmentationImageId = operationData.imageId;
         const segmentationImage = cache.getImage(currentSegmentationImageId);
         if (!segmentationImage) {
-            return;
+            return null;
         }
         segmentationScalarData = segmentationImage.getPixelData?.();
+    }
+    if (strategy.ensureImageVolumeFor3DManipulation) {
+        strategy.ensureImageVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        imageVoxelManager = operationData.imageVoxelManager;
+        imageScalarData = operationData.imageScalarData;
+        imageData = operationData.imageData;
+    }
+    else {
+        const currentImageId = viewport.getCurrentImageId();
+        if (!currentImageId) {
+            return null;
+        }
         const image = cache.getImage(currentImageId);
-        const imageData = image ? null : viewport.getImageData();
+        imageData = image ? null : viewport.getImageData();
         imageScalarData = image?.getPixelData() || imageData.getScalarData();
         imageVoxelManager = image?.voxelManager;
     }
@@ -63,6 +98,15 @@ function getStrategyData({ operationData, viewport }) {
         imageScalarData,
         segmentationVoxelManager,
         imageVoxelManager,
+        imageData,
     };
 }
+function getStrategyData({ operationData, viewport, strategy, }) {
+    if (('volumeId' in operationData && operationData.volumeId !== undefined) ||
+        ('referencedVolumeId' in operationData &&
+            operationData.referencedVolumeId !== undefined)) {
+        return getStrategyDataForVolumeViewport({ operationData });
+    }
+    return getStrategyDataForStackViewport({ operationData, viewport, strategy });
+}
 export { getStrategyData };

package/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.d.ts

@@ -1,10 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-declare function isWithinThreshold(index: number, imageScalarData: Types.PixelDataTypedArray, strategySpecificConfiguration: {
-    THRESHOLD?: {
-        threshold: number[];
-    };
-    THRESHOLD_INSIDE_CIRCLE?: {
-        threshold: number[];
-    };
+declare function isWithinThreshold(index: number, imageScalarData: Types.PixelDataTypedArray, threshold: {
+    range: number[];
 }): boolean;
 export default isWithinThreshold;

package/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.js

@@ -1,7 +1,8 @@
-function isWithinThreshold(index, imageScalarData, strategySpecificConfiguration) {
-    const { THRESHOLD, THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+function isWithinThreshold(index, imageScalarData, threshold) {
+    if (!threshold) {
+        return true;
+    }
     const voxelValue = imageScalarData[index];
-    const { threshold } = THRESHOLD || THRESHOLD_INSIDE_CIRCLE;
-    return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+    return threshold.range[0] <= voxelValue && voxelValue <= threshold.range[1];
 }
 export default isWithinThreshold;

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

@@ -4,6 +4,8 @@ type Statistics = {
     label?: string;
     value: number | number[];
     unit: null | string;
+    pointIJK?: Types.Point3;
+    pointLPS?: Types.Point3;
 };
 type NamedStatistics = {
     mean: Statistics & {

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

@@ -9,7 +9,7 @@ type LabelmapToolOperationData = {
     segmentsLocked: number[];
     viewPlaneNormal: number[];
     viewUp: number[];
-    strategySpecificConfiguration: any;
+    activeStrategy: string;
     points: Types.Point3[];
     voxelManager: any;
     override: {

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

@@ -42,9 +42,8 @@ import type { SplineCurveSegment } from './SplineCurveSegment';
 import type { SplineLineSegment } from './SplineLineSegment';
 import type { SplineProps } from './SplineProps';
 import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
-import type { PolySegConversionOptions } from './PolySeg';
 import type { IBaseTool } from './IBaseTool';
 import type { RepresentationStyle } from './../stateManagement/segmentation/SegmentationStyle';
-import type { LabelmapStyle } from './LabelmapTypes';
-import type { SurfaceStyle } from './SurfaceTypes';
-export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationRepresentation, SegmentationState, RepresentationData, RepresentationsData, SVGCursorDescriptor, SVGPoint, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, PolySegConversionOptions, IBaseTool, RepresentationStyle, Segment, SegmentationPublicInput, LabelmapStyle, ContourStyle, SurfaceStyle, };
+import type { LabelmapStyle, LabelmapSegmentationData, LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume, BaseLabelmapStyle, InactiveLabelmapStyle } from './LabelmapTypes';
+import type { SurfaceStyle, SurfaceSegmentationData, SurfaceStateStyles } from './SurfaceTypes';
+export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationRepresentation, SegmentationState, RepresentationData, RepresentationsData, SVGCursorDescriptor, SVGPoint, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, IBaseTool, RepresentationStyle, Segment, SegmentationPublicInput, LabelmapStyle, ContourStyle, SurfaceStyle, SurfaceSegmentationData, SurfaceStateStyles, LabelmapSegmentationData, LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume, BaseLabelmapStyle, InactiveLabelmapStyle, };

package/dist/esm/utilities/getPixelValueUnits.d.ts

@@ -2,6 +2,7 @@ type pixelUnitsOptions = {
     isPreScaled: boolean;
     isSuvScaled: boolean;
 };
+declare function getPixelValueUnitsImageId(imageId: string, options: pixelUnitsOptions): string;
 declare function getPixelValueUnits(modality: string, imageId: string, options: pixelUnitsOptions): string;
 export type { pixelUnitsOptions };
-export { getPixelValueUnits };
+export { getPixelValueUnits, getPixelValueUnitsImageId };

package/dist/esm/utilities/getPixelValueUnits.js

@@ -1,4 +1,8 @@
 import { metaData } from '@cornerstonejs/core';
+function getPixelValueUnitsImageId(imageId, options) {
+    const generalSeriesModule = metaData.get('generalSeriesModule', imageId);
+    return getPixelValueUnits(generalSeriesModule.modality, imageId, options);
+}
 function getPixelValueUnits(modality, imageId, options) {
     if (modality === 'CT') {
         return 'HU';
@@ -24,4 +28,4 @@ function _handlePTModality(imageId, options) {
     }
     return 'unknown';
 }
-export { getPixelValueUnits };
+export { getPixelValueUnits, getPixelValueUnitsImageId };