@cornerstonejs/tools 3.5.3 → 3.6.1

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,46 +39,82 @@ 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) {
-                state.minIJK = pointIJK;
-                state.minLPS = pointLPS;
+                state.minIJK = pointIJK ? [...pointIJK] : null;
+                state.minLPS = pointLPS ? [...pointLPS] : null;
             }
         }
         if (value > state.max[idx]) {
             state.max[idx] = value;
             if (idx === 0) {
-                state.maxIJK = pointIJK;
-                state.maxLPS = pointLPS;
+                state.maxIJK = pointIJK ? [...pointIJK] : null;
+                state.maxLPS = pointLPS ? [...pointLPS] : 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',
             label: 'Max Pixel',
             value: state.max.length === 1 ? state.max[0] : state.max,
             unit,
-            pointIJK: state.maxIJK,
-            pointLPS: state.maxLPS,
+            pointIJK: state.maxIJK ? [...state.maxIJK] : null,
+            pointLPS: state.maxLPS ? [...state.maxLPS] : null,
         },
         min: {
             name: 'min',
             label: 'Min Pixel',
             value: state.min.length === 1 ? state.min[0] : state.min,
             unit,
-            pointIJK: state.minIJK,
-            pointLPS: state.minLPS,
+            pointIJK: state.minIJK ? [...state.minIJK] : null,
+            pointLPS: state.minLPS ? [...state.minLPS] : null,
         },
         mean: {
             name: 'mean',
@@ -88,14 +130,44 @@ 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,
+        },
+        maxLPS: {
+            name: 'maxLPS',
+            label: 'Max LPS',
+            value: state.maxLPS ? Array.from(state.maxLPS) : null,
+            unit: null,
+        },
+        minLPS: {
+            name: 'minLPS',
+            label: 'Min LPS',
+            value: state.minLPS ? Array.from(state.minLPS) : null,
+            unit: null,
+        },
         pointsInShape: state.pointsInShape,
         array: [],
     };
-    named.array.push(named.max, named.mean, named.stdDev, named.stdDev, named.count);
+    named.array.push(named.min, named.max, named.mean, named.stdDev, named.median, named.skewness, named.kurtosis, named.count, named.maxLPS, named.minLPS);
     const store = state.pointsInShape !== null;
     const freshState = createBasicStatsState(store);
     state.max = freshState.max;
@@ -108,6 +180,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

@@ -14,13 +14,22 @@ function volumetricStatsCallback(state, data) {
         (length >= TEST_MAX_LOCATIONS && value < maxIJKs[0].value)) {
         return;
     }
+    const dataCopy = {
+        value: data.value,
+        pointLPS: data.pointLPS
+            ? [data.pointLPS[0], data.pointLPS[1], data.pointLPS[2]]
+            : undefined,
+        pointIJK: data.pointIJK
+            ? [data.pointIJK[0], data.pointIJK[1], data.pointIJK[2]]
+            : undefined,
+    };
     if (!length || value >= maxIJKs[length - 1].value) {
-        maxIJKs.push(data);
+        maxIJKs.push(dataCopy);
     }
     else {
         for (let i = 0; i < length; i++) {
             if (value <= maxIJKs[i].value) {
-                maxIJKs.splice(i, 0, data);
+                maxIJKs.splice(i, 0, dataCopy);
                 break;
             }
         }
@@ -42,6 +51,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/computeMetabolicStats.d.ts

@@ -0,0 +1,8 @@
+import type { NamedStatistics } from '../../types';
+declare function computeMetabolicStats({ segmentationIds, segmentIndex, }: {
+    segmentationIds: string[];
+    segmentIndex: number;
+}): Promise<NamedStatistics | {
+    [segmentIndex: number]: NamedStatistics;
+}>;
+export { computeMetabolicStats };

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

@@ -0,0 +1,58 @@
+import { utilities, getWebWorkerManager } from '@cornerstonejs/core';
+import { triggerWorkerProgress } from './utilsForWorker';
+import { WorkerTypes } from '../../enums';
+import { registerComputeWorker } from '../registerComputeWorker';
+import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+import { getReferenceVolumeForSegmentation } from './getReferenceVolumeForSegmentation';
+async function computeMetabolicStats({ segmentationIds, segmentIndex, }) {
+    registerComputeWorker();
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 0);
+    const segmentation = getSegmentation(segmentationIds[0]);
+    const { imageIds: segImageIds } = segmentation.representationData
+        .Labelmap;
+    const isValidVolume = utilities.isValidVolume(segImageIds);
+    if (!isValidVolume) {
+        throw new Error('Invalid volume - TMTV cannot be calculated');
+    }
+    const stats = await calculateForVolume({
+        segmentationIds,
+        segmentIndex,
+    });
+    return stats;
+}
+async function calculateForVolume({ segmentationIds, segmentIndex }) {
+    const labelmapVolumes = segmentationIds.map((id) => {
+        return getOrCreateSegmentationVolume(id);
+    });
+    const mergedLabelmap = createMergedLabelmapForIndex(labelmapVolumes, segmentIndex);
+    if (!mergedLabelmap) {
+        throw new Error('Invalid volume - TMTV cannot be calculated');
+    }
+    const { imageData, dimensions, direction, origin, voxelManager } = mergedLabelmap;
+    const spacing = imageData.getSpacing();
+    const segmentationScalarData = voxelManager.getCompleteScalarDataArray();
+    const segmentationInfo = {
+        scalarData: segmentationScalarData,
+        dimensions,
+        spacing,
+        origin,
+        direction,
+    };
+    const referenceVolume = getReferenceVolumeForSegmentation(segmentationIds[0]);
+    const imageInfo = {
+        dimensions: referenceVolume.dimensions,
+        spacing: referenceVolume.spacing,
+        origin: referenceVolume.origin,
+        direction: referenceVolume.direction,
+        scalarData: referenceVolume.voxelManager.getCompleteScalarDataArray(),
+    };
+    const stats = await getWebWorkerManager().executeTask('compute', 'computeMetabolicStats', {
+        segmentationInfo,
+        imageInfo,
+    });
+    triggerWorkerProgress(WorkerTypes.COMPUTE_STATISTICS, 100);
+    return stats;
+}
+export { computeMetabolicStats };

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/createMergedLabelmapForIndex.js

@@ -1,4 +1,4 @@
-import { volumeLoader, utilities as csUtils } from '@cornerstonejs/core';
+import { volumeLoader, utilities as csUtils, cache } from '@cornerstonejs/core';
 function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'mergedLabelmap') {
     labelmaps.forEach(({ direction, dimensions, origin, spacing }) => {
         if (!csUtils.isEqual(dimensions, labelmaps[0].dimensions) ||
@@ -28,7 +28,15 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
         direction: labelmap.direction,
         dimensions: labelmap.dimensions,
     };
-    const mergedVolume = volumeLoader.createLocalVolume(volumeId, options);
+    const cachedVolume = cache.getVolume(volumeId);
+    let mergedVolume;
+    if (cachedVolume) {
+        mergedVolume = cachedVolume;
+        mergedVolume.voxelManager.setCompleteScalarDataArray(outputData);
+    }
+    else {
+        mergedVolume = volumeLoader.createLocalVolume(volumeId, options);
+    }
     return mergedVolume;
 }
 export default createMergedLabelmapForIndex;

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/getOrCreateImageVolume.d.ts

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+declare function getOrCreateImageVolume(referencedImageIds: string[]): Types.IImageVolume | undefined;
+export default getOrCreateImageVolume;

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

@@ -0,0 +1,18 @@
+import { cache, volumeLoader, utilities as csUtils, } from '@cornerstonejs/core';
+function getOrCreateImageVolume(referencedImageIds) {
+    if (!referencedImageIds || referencedImageIds.length <= 1) {
+        return;
+    }
+    const isValidVolume = csUtils.isValidVolume(referencedImageIds);
+    if (!isValidVolume) {
+        return;
+    }
+    const volumeId = cache.generateVolumeId(referencedImageIds);
+    let imageVolume = cache.getVolume(volumeId);
+    if (imageVolume) {
+        return imageVolume;
+    }
+    imageVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds);
+    return imageVolume;
+}
+export default getOrCreateImageVolume;

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

@@ -1,2 +1,3 @@
-declare function getOrCreateSegmentationVolume(segmentationId: any): any;
+import { type Types } from '@cornerstonejs/core';
+declare function getOrCreateSegmentationVolume(segmentationId: any): Types.IImageVolume | undefined;
 export default getOrCreateSegmentationVolume;

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/getReferenceVolumeForSegmentation.d.ts

@@ -0,0 +1 @@
+export declare function getReferenceVolumeForSegmentation(segmentationId: string): import("@cornerstonejs/core").ImageVolume;

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

@@ -0,0 +1,34 @@
+import { cache } from '@cornerstonejs/core';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import getOrCreateImageVolume from './getOrCreateImageVolume';
+export function getReferenceVolumeForSegmentation(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return null;
+    }
+    let referenceImageIds;
+    const labelmap = segmentation.representationData.Labelmap;
+    if ('imageIds' in labelmap) {
+        const { imageIds } = labelmap;
+        const firstImage = cache.getImage(imageIds[0]);
+        const volumeInfo = cache.getVolumeContainingImageId(firstImage.referencedImageId);
+        if (volumeInfo?.volume) {
+            return volumeInfo.volume;
+        }
+        referenceImageIds = imageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
+    }
+    else if ('volumeId' in labelmap) {
+        const { volumeId, referencedVolumeId } = labelmap;
+        if (referencedVolumeId) {
+            const refVolume = cache.getVolume(referencedVolumeId);
+            if (refVolume) {
+                return refVolume;
+            }
+        }
+        const segVolume = cache.getVolume(volumeId);
+        if (segVolume) {
+            referenceImageIds = segVolume.imageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
+        }
+    }
+    return getOrCreateImageVolume(referenceImageIds);
+}

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;
+}