@cornerstonejs/tools 3.5.2 → 3.6.0

package/dist/esm/utilities/math/basic/BasicStatsCalculator.js

@@ -13,6 +13,9 @@ function createBasicStatsState(storePointData) {
         minLPS: null,
         runMean: [0],
         m2: [0],
+        m3: [0],
+        m4: [0],
+        allValues: [[]],
         pointsInShape: storePointData ? PointsManager.create3(1024) : null,
     };
 }
@@ -25,6 +28,9 @@ function basicStatsCallback(state, newValue, pointLPS = null, pointIJK = null) {
         state.sum.push(state.sum[0], state.sum[0]);
         state.runMean.push(0, 0);
         state.m2.push(state.m2[0], state.m2[0]);
+        state.m3.push(state.m3[0], state.m3[0]);
+        state.m4.push(state.m4[0], state.m4[0]);
+        state.allValues.push([], []);
     }
     if (state?.pointsInShape && pointLPS) {
         state.pointsInShape.push(pointLPS);
@@ -33,11 +39,19 @@ function basicStatsCallback(state, newValue, pointLPS = null, pointIJK = null) {
     state.count += 1;
     state.max.forEach((it, idx) => {
         const value = newArray[idx];
+        state.allValues[idx].push(value);
+        const n = state.count;
         const delta = value - state.runMean[idx];
+        const delta_n = delta / n;
+        const term1 = delta * delta_n * (n - 1);
         state.sum[idx] += value;
-        state.runMean[idx] += delta / state.count;
-        const delta2 = value - state.runMean[idx];
-        state.m2[idx] += delta * delta2;
+        state.runMean[idx] += delta_n;
+        state.m4[idx] +=
+            term1 * delta_n * delta_n * (n * n - 3 * n + 3) +
+                6 * delta_n * delta_n * state.m2[idx] -
+                4 * delta_n * state.m3[idx];
+        state.m3[idx] += term1 * delta_n * (n - 2) - 3 * delta_n * state.m2[idx];
+        state.m2[idx] += term1;
         if (value < state.min[idx]) {
             state.min[idx] = value;
             if (idx === 0) {
@@ -54,9 +68,37 @@ function basicStatsCallback(state, newValue, pointLPS = null, pointIJK = null) {
         }
     });
 }
+function calculateMedian(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+    else {
+        return sorted[mid];
+    }
+}
 function basicGetStatistics(state, unit) {
     const mean = state.sum.map((sum) => sum / state.count);
     const stdDev = state.m2.map((squaredDiffSum) => Math.sqrt(squaredDiffSum / state.count));
+    const skewness = state.m3.map((m3, idx) => {
+        const variance = state.m2[idx] / state.count;
+        if (variance === 0) {
+            return 0;
+        }
+        return m3 / (state.count * Math.pow(variance, 1.5));
+    });
+    const kurtosis = state.m4.map((m4, idx) => {
+        const variance = state.m2[idx] / state.count;
+        if (variance === 0) {
+            return 0;
+        }
+        return m4 / (state.count * variance * variance) - 3;
+    });
+    const median = state.allValues.map((values) => calculateMedian(values));
     const named = {
         max: {
             name: 'max',
@@ -88,14 +130,32 @@ function basicGetStatistics(state, unit) {
         },
         count: {
             name: 'count',
-            label: 'Pixel Count',
+            label: 'Voxel Count',
             value: state.count,
             unit: null,
         },
+        median: {
+            name: 'median',
+            label: 'Median',
+            value: median.length === 1 ? median[0] : median,
+            unit,
+        },
+        skewness: {
+            name: 'skewness',
+            label: 'Skewness',
+            value: skewness.length === 1 ? skewness[0] : skewness,
+            unit: null,
+        },
+        kurtosis: {
+            name: 'kurtosis',
+            label: 'Kurtosis',
+            value: kurtosis.length === 1 ? kurtosis[0] : kurtosis,
+            unit: null,
+        },
         pointsInShape: state.pointsInShape,
         array: [],
     };
-    named.array.push(named.max, named.mean, named.stdDev, named.stdDev, named.count);
+    named.array.push(named.max, named.mean, named.stdDev, named.median, named.skewness, named.kurtosis, named.count);
     const store = state.pointsInShape !== null;
     const freshState = createBasicStatsState(store);
     state.max = freshState.max;
@@ -108,6 +168,9 @@ function basicGetStatistics(state, unit) {
     state.minLPS = freshState.minLPS;
     state.runMean = freshState.runMean;
     state.m2 = freshState.m2;
+    state.m3 = freshState.m3;
+    state.m4 = freshState.m4;
+    state.allValues = freshState.allValues;
     state.pointsInShape = freshState.pointsInShape;
     return named;
 }

package/dist/esm/utilities/registerComputeWorker.js

@@ -1,4 +1,5 @@
 import { getWebWorkerManager } from '@cornerstonejs/core';
+import { getConfig } from '../config';
 let registered = false;
 export function registerComputeWorker() {
     if (registered) {
@@ -12,9 +13,11 @@ export function registerComputeWorker() {
         });
     };
     const workerManager = getWebWorkerManager();
+    const config = getConfig();
+    const computeWorkerConfig = config.computeWorker;
     const options = {
         maxWorkerInstances: 1,
-        autoTerminateOnIdle: {
+        autoTerminateOnIdle: computeWorkerConfig?.autoTerminateOnIdle ?? {
             enabled: true,
             idleTimeThreshold: 2000,
         },

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

@@ -42,6 +42,7 @@ function volumetricGetStatistics(state, stats, options) {
             : stats.count.value * volumeScale,
         unit: volumeUnit,
         name: 'volume',
+        label: 'Volume',
     };
     stats.maxIJKs = state.maxIJKs.filter((entry) => entry.pointIJK !== undefined);
     stats.array.push(stats.volume);

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

@@ -1,7 +1,6 @@
 import { generateContourSetsFromLabelmap } from '../contours';
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import findLargestBidirectional from './findLargestBidirectional';
-const { Labelmap } = SegmentationRepresentations;
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
 export default function contourAndFindLargestBidirectional(segmentation) {
     const contours = generateContourSetsFromLabelmap({
         segmentations: segmentation,
@@ -9,15 +8,18 @@ export default function contourAndFindLargestBidirectional(segmentation) {
     if (!contours?.length || !contours[0].sliceContours.length) {
         return;
     }
-    const { representationData, segments = [
+    const { segments = [
         null,
         { label: 'Unspecified', color: null, containedSegmentIndices: null },
     ], } = segmentation;
-    const { volumeId: segVolumeId } = representationData[Labelmap];
+    const vol = getOrCreateSegmentationVolume(segmentation.segmentationId);
+    if (!vol) {
+        return;
+    }
     const segmentIndex = segments.findIndex((it) => !!it);
     if (segmentIndex === -1) {
         return;
     }
     segments[segmentIndex].segmentIndex = segmentIndex;
-    return findLargestBidirectional(contours[0], segVolumeId, segments[segmentIndex]);
+    return findLargestBidirectional(contours[0], vol.volumeId, segments[segmentIndex]);
 }

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

@@ -1 +1,6 @@
+import type { BidirectionalData } from './createBidirectionalToolData';
 export default function findLargestBidirectional(contours: any, segVolumeId: string, segment: any): any;
+export declare function createBidirectionalForSlice(sliceContour: any, isInSegment: any, currentMax?: {
+    maxMajor: number;
+    maxMinor: number;
+}): BidirectionalData;

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

@@ -18,7 +18,7 @@ export default function findLargestBidirectional(contours, segVolumeId, segment)
     }
     return maxBidirectional;
 }
-function createBidirectionalForSlice(sliceContour, isInSegment, currentMax = { maxMajor: 0, maxMinor: 0 }) {
+export function createBidirectionalForSlice(sliceContour, isInSegment, currentMax = { maxMajor: 0, maxMinor: 0 }) {
     const { points } = sliceContour.polyData;
     const { maxMinor: currentMaxMinor, maxMajor: currentMaxMajor } = currentMax;
     let maxMajor = currentMaxMajor * currentMaxMajor;

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

@@ -1,4 +1,4 @@
-import { cache, volumeLoader } from '@cornerstonejs/core';
+import { cache, volumeLoader, utilities } from '@cornerstonejs/core';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getOrCreateSegmentationVolume(segmentationId) {
     const { representationData } = getSegmentation(segmentationId);
@@ -15,6 +15,10 @@ function getOrCreateSegmentationVolume(segmentationId) {
     if (!labelmapImageIds || labelmapImageIds.length === 1) {
         return;
     }
+    const isValidVolume = utilities.isValidVolume(labelmapImageIds);
+    if (!isValidVolume) {
+        return;
+    }
     segVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
     return segVolume;
 }

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

@@ -0,0 +1 @@
+export declare function getReferenceVolumeForSegmentationVolume(segmentationVolumeId: string): any;

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

@@ -0,0 +1,20 @@
+import { cache } from '@cornerstonejs/core';
+export function getReferenceVolumeForSegmentationVolume(segmentationVolumeId) {
+    const segmentationVolume = cache.getVolume(segmentationVolumeId);
+    if (!segmentationVolume) {
+        return null;
+    }
+    const referencedVolumeId = segmentationVolume.referencedVolumeId;
+    let imageVolume;
+    if (referencedVolumeId) {
+        imageVolume = cache.getVolume(referencedVolumeId);
+    }
+    else {
+        const imageIds = segmentationVolume.imageIds;
+        const image = cache.getImage(imageIds[0]);
+        const referencedImageId = image.referencedImageId;
+        const volumeInfo = cache.getVolumeContainingImageId(referencedImageId);
+        imageVolume = volumeInfo?.volume;
+    }
+    return imageVolume;
+}

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

@@ -0,0 +1,5 @@
+export declare function getSegmentLargestBidirectional({ segmentationId, segmentIndices, mode, }: {
+    segmentationId: any;
+    segmentIndices: any;
+    mode?: string;
+}): Promise<any>;

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

@@ -0,0 +1,54 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+import { WorkerTypes } from '../../enums';
+import { registerComputeWorker } from '../registerComputeWorker';
+import { triggerWorkerProgress, getSegmentationDataForWorker, prepareVolumeStrategyDataForWorker, prepareStackDataForWorker, } from './utilsForWorker';
+export async function getSegmentLargestBidirectional({ segmentationId, segmentIndices, mode = 'individual', }) {
+    registerComputeWorker();
+    triggerWorkerProgress(WorkerTypes.COMPUTE_LARGEST_BIDIRECTIONAL, 0);
+    const segData = getSegmentationDataForWorker(segmentationId, segmentIndices);
+    if (!segData) {
+        return;
+    }
+    const { operationData, segImageIds, reconstructableVolume, indices } = segData;
+    const bidirectionalData = reconstructableVolume
+        ? await calculateVolumeBidirectional({
+            operationData,
+            indices,
+            mode,
+        })
+        : await calculateStackBidirectional({
+            segImageIds,
+            indices,
+            mode,
+        });
+    triggerWorkerProgress(WorkerTypes.COMPUTE_LARGEST_BIDIRECTIONAL, 100);
+    return bidirectionalData;
+}
+async function calculateVolumeBidirectional({ operationData, indices, mode }) {
+    const strategyData = prepareVolumeStrategyDataForWorker(operationData);
+    const { segmentationVoxelManager, segmentationImageData } = strategyData;
+    const segmentationScalarData = segmentationVoxelManager.getCompleteScalarDataArray();
+    const segmentationInfo = {
+        scalarData: segmentationScalarData,
+        dimensions: segmentationImageData.getDimensions(),
+        spacing: segmentationImageData.getSpacing(),
+        origin: segmentationImageData.getOrigin(),
+        direction: segmentationImageData.getDirection(),
+    };
+    const bidirectionalData = await getWebWorkerManager().executeTask('compute', 'getSegmentLargestBidirectionalInternal', {
+        segmentationInfo,
+        indices,
+        mode,
+    });
+    return bidirectionalData;
+}
+async function calculateStackBidirectional({ segImageIds, indices, mode }) {
+    const { segmentationInfo } = prepareStackDataForWorker(segImageIds);
+    const bidirectionalData = await getWebWorkerManager().executeTask('compute', 'getSegmentLargestBidirectionalInternal', {
+        segmentationInfo,
+        indices,
+        mode,
+        isStack: true,
+    });
+    return bidirectionalData;
+}

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,32 @@ const processSegmentationStatistics = ({ stats, unit, spacing, segmentationImage
                 value: mean.value,
                 unit,
             };
+            updateStatsArray(stats, stats.peakValue);
         }
     }
+    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;
@@ -237,31 +199,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

@@ -26,4 +26,6 @@ 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';
+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, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, };

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

@@ -26,4 +26,6 @@ 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';
+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, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, };

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);