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

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

@@ -35,5 +35,6 @@ import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCall
 declare const roundNumber: typeof utilities.roundNumber;
 import normalizeViewportPlane from './normalizeViewportPlane';
 import IslandRemoval from './segmentation/islandRemoval';
-import { getPixelValueUnits } from './getPixelValueUnits';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };
+import { getPixelValueUnits, getPixelValueUnitsImageId } from './getPixelValueUnits';
+import * as geometricSurfaceUtils from './geometricSurfaceUtils';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, };

package/dist/esm/utilities/index.js

@@ -35,5 +35,6 @@ import { pointInSurroundingSphereCallback } from './pointInSurroundingSphereCall
 const roundNumber = utilities.roundNumber;
 import normalizeViewportPlane from './normalizeViewportPlane';
 import IslandRemoval from './segmentation/islandRemoval';
-import { getPixelValueUnits } from './getPixelValueUnits';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, };
+import { getPixelValueUnits, getPixelValueUnitsImageId, } from './getPixelValueUnits';
+import * as geometricSurfaceUtils from './geometricSurfaceUtils';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, };

package/dist/esm/utilities/math/basic/BasicStatsCalculator.d.ts

@@ -5,15 +5,20 @@ export default class BasicStatsCalculator extends Calculator {
     private static min;
     private static sum;
     private static count;
+    private static maxIJK;
+    private static maxLPS;
+    private static minIJK;
+    private static minLPS;
     private static runMean;
     private static m2;
     private static pointsInShape;
     static statsInit(options: {
         storePointData: boolean;
     }): void;
-    static statsCallback: ({ value: newValue, pointLPS }: {
+    static statsCallback: ({ value: newValue, pointLPS, pointIJK, }: {
         value: any;
         pointLPS?: any;
+        pointIJK?: any;
     }) => void;
     static getStatistics: (options?: {
         unit: string;

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

@@ -6,6 +6,10 @@ export default class BasicStatsCalculator extends Calculator {
     static { this.min = [Infinity]; }
     static { this.sum = [0]; }
     static { this.count = 0; }
+    static { this.maxIJK = null; }
+    static { this.maxLPS = null; }
+    static { this.minIJK = null; }
+    static { this.minLPS = null; }
     static { this.runMean = [0]; }
     static { this.m2 = [0]; }
     static { this.pointsInShape = PointsManager.create3(1024); }
@@ -14,7 +18,7 @@ export default class BasicStatsCalculator extends Calculator {
             BasicStatsCalculator.pointsInShape = null;
         }
     }
-    static { this.statsCallback = ({ value: newValue, pointLPS = null }) => {
+    static { this.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
         if (Array.isArray(newValue) &&
             newValue.length > 1 &&
             this.max.length === 1) {
@@ -37,7 +41,20 @@ export default class BasicStatsCalculator extends Calculator {
             const delta2 = value - this.runMean[idx];
             this.m2[idx] += delta * delta2;
             this.min[idx] = Math.min(this.min[idx], value);
-            this.max[idx] = Math.max(it, value);
+            if (value < this.min[idx]) {
+                this.min[idx] = value;
+                if (idx === 0) {
+                    this.minIJK = pointIJK;
+                    this.minLPS = pointLPS;
+                }
+            }
+            if (value > this.max[idx]) {
+                this.max[idx] = value;
+                if (idx === 0) {
+                    this.maxIJK = pointIJK;
+                    this.maxLPS = pointLPS;
+                }
+            }
         });
     }; }
     static { this.getStatistics = (options) => {
@@ -50,12 +67,16 @@ export default class BasicStatsCalculator extends Calculator {
                 label: 'Max Pixel',
                 value: singleArrayAsNumber(this.max),
                 unit,
+                pointIJK: this.maxIJK,
+                pointLPS: this.maxLPS,
             },
             min: {
                 name: 'min',
                 label: 'Min Pixel',
                 value: singleArrayAsNumber(this.min),
                 unit,
+                pointIJK: this.minIJK,
+                pointLPS: this.minLPS,
             },
             mean: {
                 name: 'mean',
@@ -85,6 +106,10 @@ export default class BasicStatsCalculator extends Calculator {
         this.m2 = [0];
         this.runMean = [0];
         this.count = 0;
+        this.maxIJK = null;
+        this.maxLPS = null;
+        this.minIJK = null;
+        this.minLPS = null;
         this.pointsInShape = PointsManager.create3(1024);
         return named;
     }; }

package/dist/esm/utilities/math/vec2/liangBarksyClip.d.ts

@@ -1 +1 @@
-export default function clip(a: any, b: any, box: any, da?: any, db?: any): 0 | 1;
+export default function clip(a: any, b: any, box: any, da?: any, db?: any): 1 | 0;

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

@@ -0,0 +1 @@
+export declare function registerComputeWorker(): void;

package/dist/esm/{stateManagement/segmentation/polySeg/registerPolySegWorker.js → utilities/registerComputeWorker.js}

@@ -1,13 +1,13 @@
 import { getWebWorkerManager } from '@cornerstonejs/core';
 let registered = false;
-export function registerPolySegWorker() {
+export function registerComputeWorker() {
     if (registered) {
         return;
     }
     registered = true;
     const workerFn = () => {
-        return new Worker(new URL('../../../workers/polySegConverters', import.meta.url), {
-            name: 'polySeg',
+        return new Worker(new URL('../workers/computeWorker.js', import.meta.url), {
+            name: 'compute',
             type: 'module',
         });
     };
@@ -19,5 +19,5 @@ export function registerPolySegWorker() {
             idleTimeThreshold: 2000,
         },
     };
-    workerManager.registerWorker('polySeg', workerFn, options);
+    workerManager.registerWorker('compute', workerFn, options);
 }

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

@@ -1,3 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-export declare function setBrushThresholdForToolGroup(toolGroupId: string, threshold: Types.Point2, otherArgs?: Record<string, unknown>): void;
+export declare function setBrushThresholdForToolGroup(toolGroupId: string, threshold: {
+    range: Types.Point2;
+    isDynamic: boolean;
+    dynamicRadius: number;
+}): void;
 export declare function getBrushThresholdForToolGroup(toolGroupId: string): any;

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

@@ -1,30 +1,30 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
-import { getRenderingEngine } from '@cornerstonejs/core';
 import { getBrushToolInstances } from './getBrushToolInstances';
-export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
+export function setBrushThresholdForToolGroup(toolGroupId, threshold) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
         return;
     }
     const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
-    const configuration = {
-        ...otherArgs,
-        ...(threshold !== undefined && { threshold }),
-    };
     brushBasedToolInstances.forEach((tool) => {
-        tool.configuration.strategySpecificConfiguration.THRESHOLD = {
-            ...tool.configuration.strategySpecificConfiguration.THRESHOLD,
-            ...configuration,
+        const activeStrategy = tool.configuration.activeStrategy;
+        if (!activeStrategy.toLowerCase().includes('threshold')) {
+            return;
+        }
+        tool.configuration = {
+            ...tool.configuration,
+            threshold: {
+                ...tool.configuration.threshold,
+                ...threshold,
+            },
         };
     });
     const viewportsInfo = toolGroup.getViewportsInfo();
     if (!viewportsInfo.length) {
         return;
     }
-    const { renderingEngineId } = viewportsInfo[0];
     const viewportIds = toolGroup.getViewportIds();
-    const renderingEngine = getRenderingEngine(renderingEngineId);
     triggerAnnotationRenderForViewportIds(viewportIds);
 }
 export function getBrushThresholdForToolGroup(toolGroupId) {
@@ -41,6 +41,5 @@ export function getBrushThresholdForToolGroup(toolGroupId) {
     if (!brushToolInstance) {
         return;
     }
-    return brushToolInstance.configuration.strategySpecificConfiguration.THRESHOLD
-        .threshold;
+    return brushToolInstance.configuration.threshold.range;
 }

package/dist/esm/{stateManagement/segmentation/polySeg → utilities/segmentation}/computeAndAddRepresentation.d.ts

@@ -1,3 +1,3 @@
-import type { SegmentationRepresentations } from '../../../enums';
+import type { SegmentationRepresentations } from '../../enums';
 declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void, onComputationComplete?: () => void): Promise<T>;
 export { computeAndAddRepresentation };

package/dist/esm/{stateManagement/segmentation/polySeg → utilities/segmentation}/computeAndAddRepresentation.js

@@ -1,12 +1,10 @@
 import { eventTarget } from '@cornerstonejs/core';
-import { Events } from '../../../enums';
-import addRepresentationData from '../internalAddRepresentationData';
-import { triggerSegmentationModified } from '../triggerSegmentationEvents';
-import debounce from '../../../utilities/debounce';
-import { registerPolySegWorker } from './registerPolySegWorker';
+import { Events } from '../../enums';
+import addRepresentationData from '../../stateManagement/segmentation/internalAddRepresentationData';
+import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import debounce from '../debounce';
 const computedRepresentations = new Map();
 async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
-    registerPolySegWorker();
     const data = await computeFunction();
     addRepresentationData({
         segmentationId,

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

@@ -0,0 +1,2 @@
+declare function getOrCreateSegmentationVolume(segmentationId: any): any;
+export default getOrCreateSegmentationVolume;

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

@@ -0,0 +1,21 @@
+import { cache, volumeLoader } from '@cornerstonejs/core';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+function getOrCreateSegmentationVolume(segmentationId) {
+    const { representationData } = getSegmentation(segmentationId);
+    let { volumeId } = representationData.Labelmap;
+    let segVolume;
+    if (volumeId) {
+        segVolume = cache.getVolume(volumeId);
+        if (segVolume) {
+            return segVolume;
+        }
+    }
+    const { imageIds: labelmapImageIds } = representationData.Labelmap;
+    volumeId = cache.generateVolumeId(labelmapImageIds);
+    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+        return;
+    }
+    segVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
+    return segVolume;
+}
+export default getOrCreateSegmentationVolume;

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

@@ -0,0 +1,5 @@
+declare function getStatistics({ segmentationId, segmentIndices, }: {
+    segmentationId: string;
+    segmentIndices: number[] | number;
+}): Promise<any>;
+export default getStatistics;

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

@@ -0,0 +1,210 @@
+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 { 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 { WorkerTypes } from '../../enums';
+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, }) {
+    registerComputeWorker();
+    triggerWorkerProgress(eventTarget, 0);
+    const segmentation = getSegmentation(segmentationId);
+    const { representationData } = segmentation;
+    const { Labelmap } = representationData;
+    if (!Labelmap) {
+        console.debug('No labelmap found for segmentation', segmentationId);
+        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 { refImageId, modalityUnitOptions } = getImageReferenceInfo(segVolumeId, segImageIds);
+    const unit = getPixelValueUnitsImageId(refImageId, modalityUnitOptions);
+    const stats = reconstructableVolume
+        ? await calculateVolumeStatistics(operationData, indices, unit)
+        : await calculateStackStatistics(segImageIds, indices, unit);
+    return stats;
+}
+async function calculateVolumeStatistics(operationData, indices, unit) {
+    const strategyData = getStrategyData({
+        operationData,
+        strategy: {
+            ensureSegmentationVolumeFor3DManipulation: ensureSegmentationVolume.ensureSegmentationVolumeFor3DManipulation,
+            ensureImageVolumeFor3DManipulation: ensureImageVolume.ensureImageVolumeFor3DManipulation,
+        },
+    });
+    const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, imageData, } = strategyData;
+    const spacing = segmentationImageData.getSpacing();
+    const { boundsIJK: boundsOrig } = segmentationVoxelManager;
+    if (!boundsOrig) {
+        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(),
+    };
+    const imageInfo = {
+        scalarData: imageScalarData,
+        dimensions: imageData.getDimensions(),
+        spacing: imageData.getSpacing(),
+        origin: imageData.getOrigin(),
+    };
+    const stats = await workerManager.executeTask('compute', 'calculateSegmentsStatisticsVolume', {
+        segmentationInfo,
+        imageInfo,
+        indices,
+    });
+    triggerWorkerProgress(eventTarget, 100);
+    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 stats.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;
+}
+async function calculateStackStatistics(segImageIds, indices, unit) {
+    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', {
+        segmentationInfo,
+        imageInfo,
+        indices,
+    });
+    triggerWorkerProgress(eventTarget, 100);
+    stats.mean.unit = unit;
+    stats.max.unit = unit;
+    stats.min.unit = unit;
+    return stats;
+}
+function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
+    const { pointIJK: centerIJK } = testMax;
+    if (!centerIJK) {
+        return;
+    }
+    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 });
+}
+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

@@ -20,4 +20,9 @@ import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
 import IslandRemoval from './islandRemoval';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, };
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+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, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };

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

@@ -20,4 +20,9 @@ import { getBrushToolInstances } from './getBrushToolInstances';
 import * as growCut from './growCut';
 import * as LabelmapMemo from './createLabelmapMemo';
 import IslandRemoval from './islandRemoval';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, };
+import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
+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, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, };

package/dist/esm/{tools/displayTools/Labelmap → utilities/segmentation}/validateLabelmap.d.ts

@@ -1,4 +1,4 @@
-import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
-import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
 export declare function validatePublic(segmentationInput: SegmentationPublicInput): void;
 export declare function validate(segmentationRepresentationData: LabelmapSegmentationData): void;

package/dist/esm/workers/computeWorker.js

@@ -0,0 +1,78 @@
+import { expose } from 'comlink';
+import { utilities } from '@cornerstonejs/core';
+import VolumetricCalculator from '../utilities/segmentation/VolumetricCalculator';
+const { VoxelManager } = utilities;
+const computeWorker = {
+    calculateSegmentsStatisticsVolume: (args) => {
+        const { segmentationInfo, imageInfo, indices } = args;
+        const { scalarData: segmentationScalarData, dimensions: segmentationDimensions, spacing: segmentationSpacing, } = segmentationInfo;
+        const { scalarData: imageScalarData, dimensions: imageDimensions } = imageInfo;
+        if (segmentationDimensions[0] !== imageDimensions[0] ||
+            segmentationDimensions[1] !== imageDimensions[1] ||
+            segmentationDimensions[2] !== imageDimensions[2]) {
+            throw new Error('Dimensions do not match to calculate statistics, different dimensions not supported yet');
+        }
+        const segVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
+            dimensions: segmentationDimensions,
+            scalarData: segmentationScalarData,
+        });
+        const imageVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
+            dimensions: imageDimensions,
+            scalarData: imageScalarData,
+        });
+        segVoxelManager.forEach(({ value, pointIJK, index }) => {
+            if (indices.indexOf(value) === -1) {
+                return;
+            }
+            const imageValue = imageVoxelManager.getAtIndex(index);
+            VolumetricCalculator.statsCallback({
+                value: imageValue,
+                pointIJK,
+            });
+        }, {
+            boundsIJK: imageVoxelManager.getDefaultBounds(),
+        });
+        const stats = VolumetricCalculator.getStatistics({
+            spacing: segmentationSpacing,
+            unit: 'mm',
+        });
+        return stats;
+    },
+    calculateSegmentsStatisticsStack: (args) => {
+        const { segmentationInfo, imageInfo, indices } = args;
+        for (let i = 0; i < segmentationInfo.length; i++) {
+            const segInfo = segmentationInfo[i];
+            const imgInfo = imageInfo[i];
+            const segDimensions = [
+                segInfo.dimensions[0],
+                segInfo.dimensions[1],
+                1,
+            ];
+            const segVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
+                dimensions: segDimensions,
+                scalarData: segInfo.scalarData,
+            });
+            const imageVoxelManager = VoxelManager.createScalarVolumeVoxelManager({
+                dimensions: segDimensions,
+                scalarData: imgInfo.scalarData,
+            });
+            segVoxelManager.forEach(({ value, pointIJK, index }) => {
+                if (indices.indexOf(value) === -1) {
+                    return;
+                }
+                const imageValue = imageVoxelManager.getAtIndex(index);
+                VolumetricCalculator.statsCallback({
+                    value: imageValue,
+                });
+            }, {
+                boundsIJK: imageVoxelManager.getDefaultBounds(),
+            });
+        }
+        const spacing = segmentationInfo[0].spacing;
+        const stats = VolumetricCalculator.getStatistics({
+            spacing,
+        });
+        return stats;
+    },
+};
+expose(computeWorker);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.3",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -104,7 +104,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.0.0-beta.2",
+    "@cornerstonejs/core": "^3.0.0-beta.3",
     "@kitware/vtk.js": "32.9.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -123,5 +123,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "0e36ef232d9195cbecdf99982dedf6b73cd9d1ee"
+  "gitHead": "d2b29db96b3ecf98c9e9f0591978423dc9f6cb3f"
 }

package/dist/esm/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.d.ts

@@ -1,16 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-export type SurfacesInfo = {
-    id: string;
-    points: number[];
-    polys: number[];
-    segmentIndex: number;
-};
-export type SurfaceClipResult = {
-    points: number[];
-    lines: number[];
-    numberOfCells: number;
-};
-export type PolyDataClipCacheType = Map<number, Map<string, SurfaceClipResult>>;
-export declare function clipAndCacheSurfacesForViewport(surfacesInfo: SurfacesInfo[], viewport: Types.IVolumeViewport): Promise<PolyDataClipCacheType>;
-export declare function generateCacheId(viewport: any, viewPlaneNormal: any, sliceIndex: any): string;
-export declare function updatePolyDataCache(segmentIndex: number, cacheId: string, polyDataResult: SurfaceClipResult): void;