@cornerstonejs/tools 3.5.3 → 3.6.1

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

@@ -1,53 +1,18 @@
-import { cache, utilities, getWebWorkerManager, eventTarget, Enums, triggerEvent, metaData, } from '@cornerstonejs/core';
-import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
-import VolumetricCalculator from './VolumetricCalculator';
-import { getStrategyData } from '../../tools/segmentation/strategies/utils/getStrategyData';
+import { utilities, getWebWorkerManager } from '@cornerstonejs/core';
+import { triggerWorkerProgress, getSegmentationDataForWorker, prepareVolumeStrategyDataForWorker, prepareStackDataForWorker, getImageReferenceInfo, } from './utilsForWorker';
 import { getPixelValueUnitsImageId } from '../getPixelValueUnits';
-import ensureSegmentationVolume from '../../tools/segmentation/strategies/compositions/ensureSegmentationVolume';
-import ensureImageVolume from '../../tools/segmentation/strategies/compositions/ensureImageVolume';
-import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
-import { registerComputeWorker } from '../registerComputeWorker';
+import VolumetricCalculator from './VolumetricCalculator';
 import { WorkerTypes } from '../../enums';
+import { registerComputeWorker } from '../registerComputeWorker';
 const radiusForVol1 = Math.pow((3 * 1000) / (4 * Math.PI), 1 / 3);
-const workerManager = getWebWorkerManager();
-const triggerWorkerProgress = (eventTarget, progress) => {
-    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-        progress,
-        type: WorkerTypes.COMPUTE_STATISTICS,
-    });
-};
 async function getStatistics({ segmentationId, segmentIndices, mode = 'collective', }) {
     registerComputeWorker();
-    triggerWorkerProgress(eventTarget, 0);
-    const segmentation = getSegmentation(segmentationId);
-    const { representationData } = segmentation;
-    const { Labelmap } = representationData;
-    if (!Labelmap) {
-        console.debug('No labelmap found for segmentation', segmentationId);
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 0);
+    const segData = getSegmentationDataForWorker(segmentationId, segmentIndices);
+    if (!segData) {
         return;
     }
-    const segVolumeId = Labelmap.volumeId;
-    const segImageIds = Labelmap.imageIds;
-    const operationData = {
-        segmentationId,
-        volumeId: segVolumeId,
-        imageIds: segImageIds,
-    };
-    let reconstructableVolume = false;
-    if (segImageIds) {
-        const refImageIds = segImageIds.map((imageId) => {
-            const image = cache.getImage(imageId);
-            return image.referencedImageId;
-        });
-        reconstructableVolume = utilities.isValidVolume(refImageIds);
-    }
-    let indices = segmentIndices;
-    if (!indices) {
-        indices = [getActiveSegmentIndex(segmentationId)];
-    }
-    else if (!Array.isArray(indices)) {
-        indices = [indices, 255];
-    }
+    const { operationData, segVolumeId, segImageIds, reconstructableVolume, indices, } = segData;
     const { refImageId, modalityUnitOptions } = getImageReferenceInfo(segVolumeId, segImageIds);
     const unit = getPixelValueUnitsImageId(refImageId, modalityUnitOptions);
     const stats = reconstructableVolume
@@ -66,13 +31,7 @@ async function getStatistics({ segmentationId, segmentIndices, mode = 'collectiv
     return stats;
 }
 async function calculateVolumeStatistics({ operationData, indices, unit, mode, }) {
-    const strategyData = getStrategyData({
-        operationData,
-        strategy: {
-            ensureSegmentationVolumeFor3DManipulation: ensureSegmentationVolume.ensureSegmentationVolumeFor3DManipulation,
-            ensureImageVolumeFor3DManipulation: ensureImageVolume.ensureImageVolumeFor3DManipulation,
-        },
-    });
+    const strategyData = prepareVolumeStrategyDataForWorker(operationData);
     const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, imageData, } = strategyData;
     const spacing = segmentationImageData.getSpacing();
     const { boundsIJK: boundsOrig } = segmentationVoxelManager;
@@ -80,26 +39,27 @@ async function calculateVolumeStatistics({ operationData, indices, unit, mode, }
         return VolumetricCalculator.getStatistics({ spacing });
     }
     const segmentationScalarData = segmentationVoxelManager.getCompleteScalarDataArray();
-    const imageScalarData = imageVoxelManager.getCompleteScalarDataArray();
     const segmentationInfo = {
         scalarData: segmentationScalarData,
         dimensions: segmentationImageData.getDimensions(),
         spacing: segmentationImageData.getSpacing(),
         origin: segmentationImageData.getOrigin(),
+        direction: segmentationImageData.getDirection(),
     };
     const imageInfo = {
-        scalarData: imageScalarData,
+        scalarData: imageVoxelManager.getCompleteScalarDataArray(),
         dimensions: imageData.getDimensions(),
         spacing: imageData.getSpacing(),
         origin: imageData.getOrigin(),
+        direction: imageData.getDirection(),
     };
-    const stats = await workerManager.executeTask('compute', 'calculateSegmentsStatisticsVolume', {
+    const stats = await getWebWorkerManager().executeTask('compute', 'calculateSegmentsStatisticsVolume', {
         segmentationInfo,
         imageInfo,
         indices,
         mode,
     });
-    triggerWorkerProgress(eventTarget, 100);
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 100);
     if (mode === 'collective') {
         return processSegmentationStatistics({
             stats,
@@ -123,6 +83,18 @@ async function calculateVolumeStatistics({ operationData, indices, unit, mode, }
         return finalStats;
     }
 }
+const updateStatsArray = (stats, newStat) => {
+    if (!stats.array) {
+        return;
+    }
+    const existingIndex = stats.array.findIndex((stat) => stat.name === newStat.name);
+    if (existingIndex !== -1) {
+        stats.array[existingIndex] = newStat;
+    }
+    else {
+        stats.array.push(newStat);
+    }
+};
 const processSegmentationStatistics = ({ stats, unit, spacing, segmentationImageData, imageVoxelManager, }) => {
     stats.mean.unit = unit;
     stats.max.unit = unit;
@@ -144,42 +116,39 @@ const processSegmentationStatistics = ({ stats, unit, spacing, segmentationImage
                 value: mean.value,
                 unit,
             };
+            stats.peakPoint = {
+                name: 'peakLPS',
+                label: 'Peak SUV Point',
+                value: testMax.pointLPS ? [...testMax.pointLPS] : null,
+                unit: null,
+            };
+            updateStatsArray(stats, stats.peakValue);
+            updateStatsArray(stats, stats.peakPoint);
         }
     }
+    if (stats.volume && stats.mean) {
+        const mtv = stats.volume.value;
+        const suvMean = stats.mean.value;
+        stats.lesionGlycolysis = {
+            name: 'lesionGlycolysis',
+            label: 'Lesion Glycolysis',
+            value: mtv * suvMean,
+            unit: `${stats.volume.unit}·${unit}`,
+        };
+        updateStatsArray(stats, stats.lesionGlycolysis);
+    }
     return stats;
 };
 async function calculateStackStatistics({ segImageIds, indices, unit, mode }) {
-    triggerWorkerProgress(eventTarget, 0);
-    const segmentationInfo = [];
-    const imageInfo = [];
-    for (const segImageId of segImageIds) {
-        const segImage = cache.getImage(segImageId);
-        const segPixelData = segImage.getPixelData();
-        const segVoxelManager = segImage.voxelManager;
-        const segSpacing = [segImage.rowPixelSpacing, segImage.columnPixelSpacing];
-        const refImageId = segImage.referencedImageId;
-        const refImage = cache.getImage(refImageId);
-        const refPixelData = refImage.getPixelData();
-        const refVoxelManager = refImage.voxelManager;
-        const refSpacing = [refImage.rowPixelSpacing, refImage.columnPixelSpacing];
-        segmentationInfo.push({
-            scalarData: segPixelData,
-            dimensions: segVoxelManager.dimensions,
-            spacing: segSpacing,
-        });
-        imageInfo.push({
-            scalarData: refPixelData,
-            dimensions: refVoxelManager.dimensions,
-            spacing: refSpacing,
-        });
-    }
-    const stats = await workerManager.executeTask('compute', 'calculateSegmentsStatisticsStack', {
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 0);
+    const { segmentationInfo, imageInfo } = prepareStackDataForWorker(segImageIds);
+    const stats = await getWebWorkerManager().executeTask('compute', 'calculateSegmentsStatisticsStack', {
         segmentationInfo,
         imageInfo,
         indices,
         mode,
     });
-    triggerWorkerProgress(eventTarget, 100);
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 100);
     const spacing = segmentationInfo[0].spacing;
     const segmentationImageData = segmentationInfo[0];
     const imageVoxelManager = imageInfo[0].voxelManager;
@@ -207,7 +176,7 @@ async function calculateStackStatistics({ segImageIds, indices, unit, mode }) {
     }
 }
 function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
-    const { pointIJK: centerIJK } = testMax;
+    const { pointIJK: centerIJK, pointLPS: centerLPS } = testMax;
     if (!centerIJK) {
         return;
     }
@@ -237,31 +206,4 @@ function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
     });
     return VolumetricCalculator.getStatistics({ spacing });
 }
-function getImageReferenceInfo(segVolumeId, segImageIds) {
-    let refImageId;
-    let modalityUnitOptions;
-    if (segVolumeId) {
-        const segmentationVolume = cache.getVolume(segVolumeId);
-        const referencedVolumeId = segmentationVolume.referencedVolumeId;
-        const volume = cache.getVolume(referencedVolumeId);
-        if (volume?.imageIds?.length > 0) {
-            refImageId = volume.imageIds[0];
-        }
-        modalityUnitOptions = {
-            isPreScaled: Object.keys(volume.scaling || {}).length > 0,
-            isSuvScaled: Boolean(volume.scaling?.PT),
-        };
-    }
-    else if (segImageIds?.length) {
-        const segImage = cache.getImage(segImageIds[0]);
-        refImageId = segImage.referencedImageId;
-        const refImage = cache.getImage(refImageId);
-        const scalingModule = metaData.get('scalingModule', refImageId);
-        modalityUnitOptions = {
-            isPreScaled: Boolean(refImage.preScale?.scaled),
-            isSuvScaled: typeof scalingModule?.preScale?.scaled === 'number',
-        };
-    }
-    return { refImageId, modalityUnitOptions };
-}
 export default getStatistics;

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

@@ -22,8 +22,12 @@ import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
 import IslandRemoval from './islandRemoval';
 import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+import getOrCreateImageVolume from './getOrCreateImageVolume';
 import getStatistics from './getStatistics';
 import * as validateLabelmap from './validateLabelmap';
 import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
 import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };
+import { getReferenceVolumeForSegmentationVolume } from './getReferenceVolumeForSegmentationVolume';
+import { getSegmentLargestBidirectional } from './getSegmentLargestBidirectional';
+import { computeMetabolicStats } from './computeMetabolicStats';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, computeMetabolicStats, };

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

@@ -22,8 +22,12 @@ import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
 import IslandRemoval from './islandRemoval';
 import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+import getOrCreateImageVolume from './getOrCreateImageVolume';
 import getStatistics from './getStatistics';
 import * as validateLabelmap from './validateLabelmap';
 import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
 import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };
+import { getReferenceVolumeForSegmentationVolume } from './getReferenceVolumeForSegmentationVolume';
+import { getSegmentLargestBidirectional } from './getSegmentLargestBidirectional';
+import { computeMetabolicStats } from './computeMetabolicStats';
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, computeMetabolicStats, };

package/dist/esm/utilities/segmentation/isLineInSegment.d.ts

@@ -1,9 +1,21 @@
 import type { Types } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export default function isLineInSegment(point1: Types.Point3, point2: Types.Point3, isInSegment: any): boolean;
+declare function createIsInSegmentMetadata({ dimensions, imageData, voxelManager, segmentIndex, containedSegmentIndices, }: {
+    dimensions: number[];
+    imageData: vtkImageData;
+    voxelManager: Types.IVoxelManager<number>;
+    segmentIndex: number;
+    containedSegmentIndices?: Set<number>;
+}): {
+    testCenter: (point1: any, point2: any) => boolean;
+    toIJK: (point: any) => vec3;
+    testIJK: (ijk: any) => boolean;
+};
 declare function createIsInSegment(segVolumeId: string, segmentIndex: number, containedSegmentIndices?: Set<number>): {
     testCenter: (point1: any, point2: any) => boolean;
     toIJK: (point: any) => vec3;
     testIJK: (ijk: any) => boolean;
 };
-export { createIsInSegment, isLineInSegment };
+export { createIsInSegment, createIsInSegmentMetadata, isLineInSegment };

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

@@ -19,25 +19,19 @@ export default function isLineInSegment(point1, point2, isInSegment) {
     }
     return true;
 }
-function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
-    const vol = cache.getVolume(segVolumeId);
-    if (!vol) {
-        console.warn(`No volume found for ${segVolumeId}`);
-        return;
-    }
-    const voxelManager = vol.voxelManager;
-    const width = vol.dimensions[0];
-    const pixelsPerSlice = width * vol.dimensions[1];
+function createIsInSegmentMetadata({ dimensions, imageData, voxelManager, segmentIndex, containedSegmentIndices, }) {
+    const width = dimensions[0];
+    const pixelsPerSlice = width * dimensions[1];
     return {
         testCenter: (point1, point2) => {
             const point = vec3.add(vec3.create(), point1, point2).map((it) => it / 2);
-            const ijk = vol.imageData.worldToIndex(point).map(Math.round);
+            const ijk = imageData.worldToIndex(point).map(Math.round);
             const [i, j, k] = ijk;
             const index = i + j * width + k * pixelsPerSlice;
             const value = voxelManager.getAtIndex(index);
             return value === segmentIndex || containedSegmentIndices?.has(value);
         },
-        toIJK: (point) => vol.imageData.worldToIndex(point),
+        toIJK: (point) => imageData.worldToIndex(point),
         testIJK: (ijk) => {
             const [i, j, k] = ijk;
             const index = Math.round(i) + Math.round(j) * width + Math.round(k) * pixelsPerSlice;
@@ -46,4 +40,18 @@ function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
         },
     };
 }
-export { createIsInSegment, isLineInSegment };
+function createIsInSegment(segVolumeId, segmentIndex, containedSegmentIndices) {
+    const vol = cache.getVolume(segVolumeId);
+    if (!vol) {
+        console.warn(`No volume found for ${segVolumeId}`);
+        return;
+    }
+    return createIsInSegmentMetadata({
+        dimensions: vol.dimensions,
+        imageData: vol.imageData,
+        voxelManager: vol.voxelManager,
+        segmentIndex,
+        containedSegmentIndices,
+    });
+}
+export { createIsInSegment, createIsInSegmentMetadata, isLineInSegment };

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

@@ -6,6 +6,7 @@ import BidirectionalTool from '../../tools/annotation/BidirectionalTool';
 import { getSegmentations } from '../../stateManagement/segmentation/getSegmentations';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 export default function segmentContourAction(element, configuration) {
+    console.warn('Deprecation Alert: There is a new getSegmentLargestBidirectional function that handles volume, stack and individual segment cases properly. This function is deprecated and will be removed in a future version.');
     const { data: configurationData } = configuration;
     const enabledElement = getEnabledElement(element);
     const segment = (configurationData.getSegment || defaultGetSegment)(enabledElement, configurationData);

package/dist/esm/utilities/segmentation/utilsForWorker.d.ts

@@ -0,0 +1,38 @@
+export declare const triggerWorkerProgress: (workerType: any, progress: any) => void;
+export declare const getSegmentationDataForWorker: (segmentationId: any, segmentIndices: any) => {
+    operationData: {
+        segmentationId: any;
+        volumeId: string;
+        imageIds: string[];
+    };
+    segVolumeId: string;
+    segImageIds: string[];
+    reconstructableVolume: boolean;
+    indices: any;
+};
+export declare const prepareVolumeStrategyDataForWorker: (operationData: any) => {
+    segmentationImageData: any;
+    segmentationScalarData: any;
+    imageScalarData: any;
+    segmentationVoxelManager: any;
+    imageVoxelManager: any;
+    imageData: any;
+};
+export declare const prepareImageInfo: (imageVoxelManager: any, imageData: any) => {
+    scalarData: any;
+    dimensions: any;
+    spacing: any;
+    origin: any;
+    direction: any;
+};
+export declare const prepareStackDataForWorker: (segImageIds: any) => {
+    segmentationInfo: any[];
+    imageInfo: any[];
+};
+export declare const getImageReferenceInfo: (segVolumeId: any, segImageIds: any) => {
+    refImageId: any;
+    modalityUnitOptions: {
+        isPreScaled: boolean;
+        isSuvScaled: boolean;
+    };
+};

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

@@ -0,0 +1,125 @@
+import { cache, utilities, eventTarget, Enums, triggerEvent, metaData, } from '@cornerstonejs/core';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { getStrategyData } from '../../tools/segmentation/strategies/utils/getStrategyData';
+import ensureSegmentationVolume from '../../tools/segmentation/strategies/compositions/ensureSegmentationVolume';
+import ensureImageVolume from '../../tools/segmentation/strategies/compositions/ensureImageVolume';
+export const triggerWorkerProgress = (workerType, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: workerType,
+    });
+};
+export const getSegmentationDataForWorker = (segmentationId, segmentIndices) => {
+    const segmentation = getSegmentation(segmentationId);
+    const { representationData } = segmentation;
+    const { Labelmap } = representationData;
+    if (!Labelmap) {
+        console.debug('No labelmap found for segmentation', segmentationId);
+        return null;
+    }
+    const segVolumeId = Labelmap.volumeId;
+    const segImageIds = Labelmap.imageIds;
+    const operationData = {
+        segmentationId,
+        volumeId: segVolumeId,
+        imageIds: segImageIds,
+    };
+    let reconstructableVolume = false;
+    if (segImageIds) {
+        const refImageIds = segImageIds.map((imageId) => {
+            const image = cache.getImage(imageId);
+            return image.referencedImageId;
+        });
+        reconstructableVolume = utilities.isValidVolume(refImageIds);
+    }
+    let indices = segmentIndices;
+    if (!indices) {
+        indices = [getActiveSegmentIndex(segmentationId)];
+    }
+    else if (!Array.isArray(indices)) {
+        indices = [indices, 255];
+    }
+    return {
+        operationData,
+        segVolumeId,
+        segImageIds,
+        reconstructableVolume,
+        indices,
+    };
+};
+export const prepareVolumeStrategyDataForWorker = (operationData) => {
+    return getStrategyData({
+        operationData,
+        strategy: {
+            ensureSegmentationVolumeFor3DManipulation: ensureSegmentationVolume.ensureSegmentationVolumeFor3DManipulation,
+            ensureImageVolumeFor3DManipulation: ensureImageVolume.ensureImageVolumeFor3DManipulation,
+        },
+    });
+};
+export const prepareImageInfo = (imageVoxelManager, imageData) => {
+    const imageScalarData = imageVoxelManager.getCompleteScalarDataArray();
+    return {
+        scalarData: imageScalarData,
+        dimensions: imageData.getDimensions(),
+        spacing: imageData.getSpacing(),
+        origin: imageData.getOrigin(),
+        direction: imageData.getDirection(),
+    };
+};
+export const prepareStackDataForWorker = (segImageIds) => {
+    const segmentationInfo = [];
+    const imageInfo = [];
+    for (const segImageId of segImageIds) {
+        const segImage = cache.getImage(segImageId);
+        const segPixelData = segImage.getPixelData();
+        const { origin, direction, spacing, dimensions } = utilities.getImageDataMetadata(segImage);
+        segmentationInfo.push({
+            scalarData: segPixelData,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+        });
+        const refImageId = segImage.referencedImageId;
+        if (refImageId) {
+            const refImage = cache.getImage(refImageId);
+            const refPixelData = refImage.getPixelData();
+            const refVoxelManager = refImage.voxelManager;
+            const refSpacing = [
+                refImage.rowPixelSpacing,
+                refImage.columnPixelSpacing,
+            ];
+            imageInfo.push({
+                scalarData: refPixelData,
+                dimensions: refVoxelManager
+                    ? refVoxelManager.dimensions
+                    : [refImage.columns, refImage.rows, 1],
+                spacing: refSpacing,
+            });
+        }
+    }
+    return { segmentationInfo, imageInfo };
+};
+export const getImageReferenceInfo = (segVolumeId, segImageIds) => {
+    let refImageId;
+    if (segVolumeId) {
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const imageIds = segmentationVolume.imageIds;
+        const cachedImage = cache.getImage(imageIds[0]);
+        if (cachedImage) {
+            refImageId = cachedImage.referencedImageId;
+        }
+    }
+    else if (segImageIds?.length) {
+        const segImage = cache.getImage(segImageIds[0]);
+        refImageId = segImage.referencedImageId;
+    }
+    const refImage = cache.getImage(refImageId);
+    const scalingModule = metaData.get('scalingModule', refImageId);
+    const modalityUnitOptions = {
+        isPreScaled: Boolean(refImage.preScale?.scaled),
+        isSuvScaled: typeof scalingModule?.suvbw === 'number',
+    };
+    return { refImageId, modalityUnitOptions };
+};