@cornerstonejs/tools 3.1.1 → 3.2.0

package/dist/esm/enums/Events.d.ts

@@ -3,6 +3,7 @@ declare enum Events {
     TOOLGROUP_VIEWPORT_ADDED = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_ADDED",
     TOOLGROUP_VIEWPORT_REMOVED = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED",
     TOOL_MODE_CHANGED = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED",
+    CROSSHAIR_TOOL_CENTER_CHANGED = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED",
     ANNOTATION_ADDED = "CORNERSTONE_TOOLS_ANNOTATION_ADDED",
     ANNOTATION_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED",
     ANNOTATION_MODIFIED = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED",

package/dist/esm/enums/Events.js

@@ -4,6 +4,7 @@ var Events;
     Events["TOOLGROUP_VIEWPORT_ADDED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_ADDED";
     Events["TOOLGROUP_VIEWPORT_REMOVED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED";
     Events["TOOL_MODE_CHANGED"] = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED";
+    Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";

package/dist/esm/tools/CrosshairsTool.d.ts

@@ -33,6 +33,7 @@ declare class CrosshairsTool extends AnnotationTool {
     resetCrosshairs: () => void;
     computeToolCenter: () => void;
     _computeToolCenter: (viewportsInfo: any) => void;
+    setToolCenter(toolCenter: Types.Point3, suppressEvents?: boolean): void;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => CrosshairsAnnotation;
     cancel: () => void;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;

package/dist/esm/tools/CrosshairsTool.js

@@ -2,7 +2,7 @@ import { vec2, vec3 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
 import { AnnotationTool } from './base';
-import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, CONSTANTS, } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, CONSTANTS, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { getToolGroup, getToolGroupForViewport, } from '../store/ToolGroupManager';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement/annotation/annotationState';
 import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLine as drawLineSvg, } from '../drawingSvg';
@@ -162,8 +162,8 @@ class CrosshairsTool extends AnnotationTool {
             const firstPlane = csUtils.planar.planeEquation(normal1, point1);
             const secondPlane = csUtils.planar.planeEquation(normal2, point2);
             const thirdPlane = csUtils.planar.planeEquation(normal3, point3);
-            this.toolCenter = csUtils.planar.threePlaneIntersection(firstPlane, secondPlane, thirdPlane);
-            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
+            const toolCenter = csUtils.planar.threePlaneIntersection(firstPlane, secondPlane, thirdPlane);
+            this.setToolCenter(toolCenter);
         };
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
@@ -258,6 +258,10 @@ class CrosshairsTool extends AnnotationTool {
                     this.toolCenter[0] += deltaCameraPosition[0];
                     this.toolCenter[1] += deltaCameraPosition[1];
                     this.toolCenter[2] += deltaCameraPosition[2];
+                    triggerEvent(eventTarget, Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
+                        toolGroupId: this.toolGroupId,
+                        toolCenter: this.toolCenter,
+                    });
                 }
             }
             if (this.configuration.autoPan?.enabled) {
@@ -1171,6 +1175,17 @@ class CrosshairsTool extends AnnotationTool {
             }
         });
     }
+    setToolCenter(toolCenter, suppressEvents = false) {
+        this.toolCenter = toolCenter;
+        const viewportsInfo = this._getViewportsInfo();
+        triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
+        if (!suppressEvents) {
+            triggerEvent(eventTarget, Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
+                toolGroupId: this.toolGroupId,
+                toolCenter: this.toolCenter,
+            });
+        }
+    }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;

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

@@ -2,6 +2,7 @@ declare const getCalibratedLengthUnitsAndScale: (image: any, handles: any) => {
     unit: string;
     areaUnit: string;
     scale: number;
+    volumeUnit: string;
 };
 declare const getCalibratedProbeUnitsAndValue: (image: any, handles: any) => {
     units: string[];

package/dist/esm/utilities/getCalibratedUnits.js

@@ -1,6 +1,7 @@
 import { Enums, utilities } from '@cornerstonejs/core';
 const { CalibrationTypes } = Enums;
 const PIXEL_UNITS = 'px';
+const VOXEL_UNITS = 'voxels';
 const SUPPORTED_REGION_DATA_TYPES = [
     1,
     2,
@@ -33,15 +34,21 @@ const SQUARE = '\xb2';
 const getCalibratedLengthUnitsAndScale = (image, handles) => {
     const { calibration, hasPixelSpacing } = image;
     let unit = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    const volumeUnit = hasPixelSpacing ? 'mm\xb3' : VOXEL_UNITS;
     let areaUnit = unit + SQUARE;
     let scale = 1;
     let calibrationType = '';
     if (!calibration ||
         (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
-        return { unit, areaUnit, scale };
+        return { unit, areaUnit, scale, volumeUnit };
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return { unit: PIXEL_UNITS, areaUnit: PIXEL_UNITS + SQUARE, scale };
+        return {
+            unit: PIXEL_UNITS,
+            areaUnit: PIXEL_UNITS + SQUARE,
+            scale,
+            volumeUnit: VOXEL_UNITS,
+        };
     }
     if (calibration.sequenceOfUltrasoundRegions) {
         let imageIndex1, imageIndex2;
@@ -62,7 +69,7 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
             imageIndex2[1] >= region.regionLocationMinY0 &&
             imageIndex2[1] <= region.regionLocationMaxY1);
         if (!regions?.length) {
-            return { unit, areaUnit, scale };
+            return { unit, areaUnit, scale, volumeUnit };
         }
         regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
             SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
@@ -71,6 +78,7 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
                 unit: PIXEL_UNITS,
                 areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
+                volumeUnit: VOXEL_UNITS,
             };
         }
         const region = regions[0];
@@ -88,6 +96,7 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
                 unit: PIXEL_UNITS,
                 areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
+                volumeUnit: VOXEL_UNITS,
             };
         }
     }
@@ -107,6 +116,7 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         unit: unit + (calibrationType ? ` ${calibrationType}` : ''),
         areaUnit: areaUnit + (calibrationType ? ` ${calibrationType}` : ''),
         scale,
+        volumeUnit: volumeUnit + (calibrationType ? ` ${calibrationType}` : ''),
     };
 };
 const getCalibratedProbeUnitsAndValue = (image, handles) => {

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

@@ -1,26 +1,35 @@
 import type { NamedStatistics } from '../../../types';
-import Calculator from './Calculator';
-export default class BasicStatsCalculator extends Calculator {
-    private static max;
-    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;
+import { Calculator, InstanceCalculator } from './Calculator';
+import type { Types } from '@cornerstonejs/core';
+export declare class BasicStatsCalculator extends Calculator {
+    private static state;
     static statsInit(options: {
         storePointData: boolean;
     }): void;
     static statsCallback: ({ value: newValue, pointLPS, pointIJK, }: {
-        value: any;
-        pointLPS?: any;
-        pointIJK?: any;
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3 | null;
+        pointIJK?: Types.Point3 | null;
     }) => void;
     static getStatistics: (options?: {
         unit: string;
     }) => NamedStatistics;
 }
+export declare class InstanceBasicStatsCalculator extends InstanceCalculator {
+    private state;
+    constructor(options: {
+        storePointData: boolean;
+    });
+    statsInit(options: {
+        storePointData: boolean;
+    }): void;
+    statsCallback(data: {
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3 | null;
+        pointIJK?: Types.Point3 | null;
+    }): void;
+    getStatistics(options?: {
+        unit: string;
+        spacing?: number[] | number;
+    }): NamedStatistics;
+}

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

@@ -1,119 +1,144 @@
 import { utilities } from '@cornerstonejs/core';
-import Calculator from './Calculator';
+import { Calculator, InstanceCalculator } from './Calculator';
 const { PointsManager } = utilities;
-export default class BasicStatsCalculator extends Calculator {
-    static { this.max = [-Infinity]; }
-    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); }
+function createBasicStatsState(storePointData) {
+    return {
+        max: [-Infinity],
+        min: [Infinity],
+        sum: [0],
+        count: 0,
+        maxIJK: null,
+        maxLPS: null,
+        minIJK: null,
+        minLPS: null,
+        runMean: [0],
+        m2: [0],
+        pointsInShape: storePointData ? PointsManager.create3(1024) : null,
+    };
+}
+function basicStatsCallback(state, newValue, pointLPS = null, pointIJK = null) {
+    if (Array.isArray(newValue) &&
+        newValue.length > 1 &&
+        state.max.length === 1) {
+        state.max.push(state.max[0], state.max[0]);
+        state.min.push(state.min[0], state.min[0]);
+        state.sum.push(state.sum[0], state.sum[0]);
+        state.runMean.push(0, 0);
+        state.m2.push(state.m2[0], state.m2[0]);
+    }
+    if (state?.pointsInShape && pointLPS) {
+        state.pointsInShape.push(pointLPS);
+    }
+    const newArray = Array.isArray(newValue) ? newValue : [newValue];
+    state.count += 1;
+    state.max.forEach((it, idx) => {
+        const value = newArray[idx];
+        const delta = value - state.runMean[idx];
+        state.sum[idx] += value;
+        state.runMean[idx] += delta / state.count;
+        const delta2 = value - state.runMean[idx];
+        state.m2[idx] += delta * delta2;
+        state.min[idx] = Math.min(state.min[idx], value);
+        if (value < state.min[idx]) {
+            state.min[idx] = value;
+            if (idx === 0) {
+                state.minIJK = pointIJK;
+                state.minLPS = pointLPS;
+            }
+        }
+        if (value > state.max[idx]) {
+            state.max[idx] = value;
+            if (idx === 0) {
+                state.maxIJK = pointIJK;
+                state.maxLPS = pointLPS;
+            }
+        }
+    });
+}
+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 named = {
+        max: {
+            name: 'max',
+            label: 'Max Pixel',
+            value: state.max.length === 1 ? state.max[0] : state.max,
+            unit,
+            pointIJK: state.maxIJK,
+            pointLPS: state.maxLPS,
+        },
+        min: {
+            name: 'min',
+            label: 'Min Pixel',
+            value: state.min.length === 1 ? state.min[0] : state.min,
+            unit,
+            pointIJK: state.minIJK,
+            pointLPS: state.minLPS,
+        },
+        mean: {
+            name: 'mean',
+            label: 'Mean Pixel',
+            value: mean.length === 1 ? mean[0] : mean,
+            unit,
+        },
+        stdDev: {
+            name: 'stdDev',
+            label: 'Standard Deviation',
+            value: stdDev.length === 1 ? stdDev[0] : stdDev,
+            unit,
+        },
+        count: {
+            name: 'count',
+            label: 'Pixel Count',
+            value: state.count,
+            unit: null,
+        },
+        pointsInShape: state.pointsInShape,
+        array: [],
+    };
+    named.array.push(named.max, named.mean, named.stdDev, named.stdDev, named.count);
+    const store = state.pointsInShape !== null;
+    const freshState = createBasicStatsState(store);
+    state.max = freshState.max;
+    state.min = freshState.min;
+    state.sum = freshState.sum;
+    state.count = freshState.count;
+    state.maxIJK = freshState.maxIJK;
+    state.maxLPS = freshState.maxLPS;
+    state.minIJK = freshState.minIJK;
+    state.minLPS = freshState.minLPS;
+    state.runMean = freshState.runMean;
+    state.m2 = freshState.m2;
+    state.pointsInShape = freshState.pointsInShape;
+    return named;
+}
+export class BasicStatsCalculator extends Calculator {
+    static { this.state = createBasicStatsState(true); }
     static statsInit(options) {
         if (!options.storePointData) {
-            BasicStatsCalculator.pointsInShape = null;
+            this.state.pointsInShape = null;
         }
+        this.state = createBasicStatsState(options.storePointData);
     }
     static { this.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
-        if (Array.isArray(newValue) &&
-            newValue.length > 1 &&
-            this.max.length === 1) {
-            this.max.push(this.max[0], this.max[0]);
-            this.min.push(this.min[0], this.min[0]);
-            this.sum.push(this.sum[0], this.sum[0]);
-            this.runMean.push(0, 0);
-            this.m2.push(this.m2[0], this.m2[0]);
-        }
-        if (this.pointsInShape && pointLPS) {
-            this.pointsInShape?.push(pointLPS);
-        }
-        const newArray = Array.isArray(newValue) ? newValue : [newValue];
-        this.count += 1;
-        this.max.map((it, idx) => {
-            const value = newArray[idx];
-            const delta = value - this.runMean[idx];
-            this.sum[idx] += value;
-            this.runMean[idx] += delta / this.count;
-            const delta2 = value - this.runMean[idx];
-            this.m2[idx] += delta * delta2;
-            this.min[idx] = Math.min(this.min[idx], 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;
-                }
-            }
-        });
+        basicStatsCallback(this.state, newValue, pointLPS, pointIJK);
     }; }
     static { this.getStatistics = (options) => {
-        const mean = this.sum.map((sum) => sum / this.count);
-        const stdDev = this.m2.map((squaredDiffSum) => Math.sqrt(squaredDiffSum / this.count));
-        const unit = options?.unit || null;
-        const named = {
-            max: {
-                name: 'max',
-                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',
-                label: 'Mean Pixel',
-                value: singleArrayAsNumber(mean),
-                unit,
-            },
-            stdDev: {
-                name: 'stdDev',
-                label: 'Standard Deviation',
-                value: singleArrayAsNumber(stdDev),
-                unit,
-            },
-            count: {
-                name: 'count',
-                label: 'Pixel Count',
-                value: this.count,
-                unit: null,
-            },
-            pointsInShape: this.pointsInShape,
-            array: [],
-        };
-        named.array.push(named.max, named.mean, named.stdDev, named.stdDev, named.count);
-        this.max = [-Infinity];
-        this.min = [Infinity];
-        this.sum = [0];
-        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;
+        return basicGetStatistics(this.state, options?.unit);
     }; }
 }
-function singleArrayAsNumber(val) {
-    return val.length === 1 ? val[0] : val;
+export class InstanceBasicStatsCalculator extends InstanceCalculator {
+    constructor(options) {
+        super(options);
+        this.state = createBasicStatsState(options.storePointData);
+    }
+    statsInit(options) {
+        this.state = createBasicStatsState(options.storePointData);
+    }
+    statsCallback(data) {
+        basicStatsCallback(this.state, data.value, data.pointLPS, data.pointIJK);
+    }
+    getStatistics(options) {
+        return basicGetStatistics(this.state, options?.unit);
+    }
 }

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

@@ -1,8 +1,11 @@
 import type { NamedStatistics } from '../../../types';
-declare abstract class Calculator {
-    static run: ({ value }: {
-        value: any;
-    }) => void;
+export declare abstract class Calculator {
     static getStatistics: () => NamedStatistics;
 }
-export default Calculator;
+export declare class InstanceCalculator {
+    private storePointData;
+    constructor(options: {
+        storePointData: boolean;
+    });
+    getStatistics(): void;
+}

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

@@ -1,3 +1,10 @@
-class Calculator {
+export class Calculator {
+}
+export class InstanceCalculator {
+    constructor(options) {
+        this.storePointData = options.storePointData;
+    }
+    getStatistics() {
+        console.debug('InstanceCalculator getStatistics called');
+    }
 }
-export default Calculator;

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

@@ -1,3 +1,3 @@
-import BasicStatsCalculator from './BasicStatsCalculator';
-import Calculator from './Calculator';
-export { BasicStatsCalculator, Calculator };
+import { BasicStatsCalculator, InstanceBasicStatsCalculator } from './BasicStatsCalculator';
+import { Calculator, InstanceCalculator } from './Calculator';
+export { BasicStatsCalculator, InstanceBasicStatsCalculator, Calculator, InstanceCalculator, };

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

@@ -1,3 +1,3 @@
-import BasicStatsCalculator from './BasicStatsCalculator';
-import Calculator from './Calculator';
-export { BasicStatsCalculator, Calculator };
+import { BasicStatsCalculator, InstanceBasicStatsCalculator, } from './BasicStatsCalculator';
+import { Calculator, InstanceCalculator } from './Calculator';
+export { BasicStatsCalculator, InstanceBasicStatsCalculator, Calculator, InstanceCalculator, };

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

@@ -0,0 +1,26 @@
+import type { Types } from '@cornerstonejs/core';
+import type { NamedStatistics } from '../../types';
+export default class SegmentStatsCalculator {
+    private static calculators;
+    private static indices;
+    private static mode;
+    static statsInit(options: {
+        storePointData: boolean;
+        indices: number[];
+        mode: 'collective' | 'individual';
+    }): void;
+    static statsCallback(data: {
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3;
+        pointIJK?: Types.Point3;
+        segmentIndex?: number;
+    }): void;
+    static getStatistics(options?: {
+        spacing?: number[] | number;
+        unit?: string;
+        calibration?: unknown;
+        hasPixelSpacing?: boolean;
+    }): NamedStatistics | {
+        [segmentIndex: number]: NamedStatistics;
+    };
+}

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

@@ -0,0 +1,44 @@
+import { InstanceVolumetricCalculator } from './VolumetricCalculator';
+export default class SegmentStatsCalculator {
+    static { this.calculators = new Map(); }
+    static { this.indices = []; }
+    static { this.mode = 'collective'; }
+    static statsInit(options) {
+        const { storePointData, indices, mode } = options;
+        this.mode = mode;
+        this.indices = indices;
+        this.calculators.clear();
+        if (this.mode === 'individual') {
+            indices.forEach((index) => {
+                this.calculators.set(index, new InstanceVolumetricCalculator({ storePointData }));
+            });
+        }
+        else {
+            this.calculators.set(indices, new InstanceVolumetricCalculator({ storePointData }));
+        }
+    }
+    static statsCallback(data) {
+        const { segmentIndex, ...statsData } = data;
+        if (!segmentIndex) {
+            throw new Error('Segment index is required for stats calculation');
+        }
+        const calculator = this.mode === 'individual'
+            ? this.calculators.get(segmentIndex)
+            : this.calculators.get(this.indices);
+        if (!calculator) {
+            throw new Error(`No calculator found for segment ${segmentIndex}`);
+        }
+        calculator.statsCallback(statsData);
+    }
+    static getStatistics(options) {
+        if (this.mode === 'individual') {
+            const result = {};
+            this.calculators.forEach((calculator, segmentIndex) => {
+                result[segmentIndex] = calculator.getStatistics(options);
+            });
+            return result;
+        }
+        const calculator = this.calculators.get(this.indices);
+        return calculator.getStatistics(options);
+    }
+}

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

@@ -1,15 +1,41 @@
 import type { Types } from '@cornerstonejs/core';
 import type { NamedStatistics } from '../../types';
-import { BasicStatsCalculator } from '../math/basic';
-export default class VolumetricCalculator extends BasicStatsCalculator {
-    private static maxIJKs;
+import { BasicStatsCalculator, InstanceBasicStatsCalculator } from '../math/basic/BasicStatsCalculator';
+export declare class VolumetricCalculator extends BasicStatsCalculator {
+    private static volumetricState;
+    static statsInit(options: {
+        storePointData: boolean;
+    }): void;
+    static statsCallback(data: {
+        value: number | Types.RGB;
+        pointLPS?: Types.Point3;
+        pointIJK?: Types.Point3;
+    }): void;
     static getStatistics(options: {
-        spacing?: number;
+        spacing?: number[] | number;
         unit?: string;
+        calibration?: unknown;
+        hasPixelSpacing?: boolean;
     }): NamedStatistics;
-    static statsCallback(data: {
+}
+export declare class InstanceVolumetricCalculator extends InstanceBasicStatsCalculator {
+    private volumetricState;
+    constructor(options: {
+        storePointData: boolean;
+    });
+    statsInit(options: {
+        storePointData: boolean;
+    }): void;
+    statsCallback(data: {
         value: number | Types.RGB;
         pointLPS?: Types.Point3;
         pointIJK?: Types.Point3;
     }): void;
+    getStatistics(options?: {
+        spacing?: number[] | number;
+        unit?: string;
+        calibration?: unknown;
+        hasPixelSpacing?: boolean;
+    }): NamedStatistics;
 }
+export default VolumetricCalculator;

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

@@ -1,48 +1,96 @@
-import { BasicStatsCalculator } from '../math/basic';
+import { BasicStatsCalculator, InstanceBasicStatsCalculator, } from '../math/basic/BasicStatsCalculator';
+import { getCalibratedLengthUnitsAndScale } from '../getCalibratedUnits';
 const TEST_MAX_LOCATIONS = 10;
-export default class VolumetricCalculator extends BasicStatsCalculator {
-    static { this.maxIJKs = []; }
-    static getStatistics(options) {
-        const { spacing } = options;
-        const stats = BasicStatsCalculator.getStatistics();
-        const volumeUnit = spacing ? 'mm\xb3' : 'voxels\xb3';
-        const volumeScale = spacing
-            ? spacing[0] * spacing[1] * spacing[2] * 1000
-            : 1;
-        stats.volume = {
-            value: Array.isArray(stats.count.value)
-                ? stats.count.value.map((v) => v * volumeScale)
-                : stats.count.value * volumeScale,
-            unit: volumeUnit,
-            name: 'volume',
-        };
-        stats.maxIJKs = this.maxIJKs;
-        stats.array.push(stats.volume);
-        this.maxIJKs = [];
-        return stats;
+function createVolumetricState() {
+    return {
+        maxIJKs: [],
+    };
+}
+function volumetricStatsCallback(state, data) {
+    const { value } = data;
+    const { maxIJKs } = state;
+    const length = maxIJKs.length;
+    if (typeof value !== 'number' ||
+        (length >= TEST_MAX_LOCATIONS && value < maxIJKs[0].value)) {
+        return;
     }
-    static statsCallback(data) {
-        BasicStatsCalculator.statsCallback(data);
-        const { value } = data;
-        const { maxIJKs } = this;
-        const { length } = maxIJKs;
-        if (typeof value !== 'number' ||
-            (length >= TEST_MAX_LOCATIONS && value < maxIJKs[0].value)) {
-            return;
-        }
-        if (!length || value >= maxIJKs[length - 1].value) {
-            maxIJKs.push(data);
-        }
-        else {
-            for (let i = 0; i < length; i++) {
-                if (value <= maxIJKs[i].value) {
-                    maxIJKs.splice(i, 0, data);
-                    break;
-                }
+    if (!length || value >= maxIJKs[length - 1].value) {
+        maxIJKs.push(data);
+    }
+    else {
+        for (let i = 0; i < length; i++) {
+            if (value <= maxIJKs[i].value) {
+                maxIJKs.splice(i, 0, data);
+                break;
             }
         }
-        if (length >= TEST_MAX_LOCATIONS) {
-            maxIJKs.splice(0, 1);
-        }
+    }
+    if (length >= TEST_MAX_LOCATIONS) {
+        maxIJKs.splice(0, 1);
+    }
+}
+function volumetricGetStatistics(state, stats, options) {
+    const { spacing, calibration } = options;
+    const { volumeUnit } = getCalibratedLengthUnitsAndScale({
+        calibration,
+        hasPixelSpacing: true,
+    }, []);
+    const volumeScale = spacing ? spacing[0] * spacing[1] * spacing[2] * 1000 : 1;
+    stats.volume = {
+        value: Array.isArray(stats.count.value)
+            ? stats.count.value.map((v) => v * volumeScale)
+            : stats.count.value * volumeScale,
+        unit: volumeUnit,
+        name: 'volume',
+    };
+    stats.maxIJKs = state.maxIJKs.filter((entry) => entry.pointIJK !== undefined);
+    stats.array.push(stats.volume);
+    state.maxIJKs = [];
+    return stats;
+}
+export class VolumetricCalculator extends BasicStatsCalculator {
+    static { this.volumetricState = createVolumetricState(); }
+    static statsInit(options) {
+        super.statsInit(options);
+        this.volumetricState = createVolumetricState();
+    }
+    static statsCallback(data) {
+        super.statsCallback(data);
+        volumetricStatsCallback(this.volumetricState, data);
+    }
+    static getStatistics(options) {
+        const optionsWithUnit = {
+            ...options,
+            unit: options?.unit || 'none',
+            calibration: options?.calibration,
+            hasPixelSpacing: options?.hasPixelSpacing,
+        };
+        const stats = super.getStatistics(optionsWithUnit);
+        return volumetricGetStatistics(this.volumetricState, stats, optionsWithUnit);
+    }
+}
+export class InstanceVolumetricCalculator extends InstanceBasicStatsCalculator {
+    constructor(options) {
+        super(options);
+        this.volumetricState = createVolumetricState();
+    }
+    statsInit(options) {
+        super.statsInit(options);
+        this.volumetricState = createVolumetricState();
+    }
+    statsCallback(data) {
+        super.statsCallback(data);
+        volumetricStatsCallback(this.volumetricState, data);
+    }
+    getStatistics(options) {
+        const optionsWithUnit = {
+            ...options,
+            unit: options?.unit || 'none',
+            calibration: options?.calibration,
+            hasPixelSpacing: options?.hasPixelSpacing,
+        };
+        const stats = super.getStatistics(optionsWithUnit);
+        return volumetricGetStatistics(this.volumetricState, stats, optionsWithUnit);
     }
 }
+export default VolumetricCalculator;

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

@@ -1,5 +1,9 @@
-declare function getStatistics({ segmentationId, segmentIndices, }: {
+import type { NamedStatistics } from '../../types';
+declare function getStatistics({ segmentationId, segmentIndices, mode, }: {
     segmentationId: string;
     segmentIndices: number[] | number;
-}): Promise<any>;
+    mode?: 'collective' | 'individual';
+}): Promise<NamedStatistics | {
+    [segmentIndex: number]: NamedStatistics;
+}>;
 export default getStatistics;

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

@@ -16,7 +16,7 @@ const triggerWorkerProgress = (eventTarget, progress) => {
         type: WorkerTypes.COMPUTE_STATISTICS,
     });
 };
-async function getStatistics({ segmentationId, segmentIndices, }) {
+async function getStatistics({ segmentationId, segmentIndices, mode = 'collective', }) {
     registerComputeWorker();
     triggerWorkerProgress(eventTarget, 0);
     const segmentation = getSegmentation(segmentationId);
@@ -51,11 +51,21 @@ async function getStatistics({ segmentationId, segmentIndices, }) {
     const { refImageId, modalityUnitOptions } = getImageReferenceInfo(segVolumeId, segImageIds);
     const unit = getPixelValueUnitsImageId(refImageId, modalityUnitOptions);
     const stats = reconstructableVolume
-        ? await calculateVolumeStatistics(operationData, indices, unit)
-        : await calculateStackStatistics(segImageIds, indices, unit);
+        ? await calculateVolumeStatistics({
+            operationData,
+            indices,
+            unit,
+            mode,
+        })
+        : await calculateStackStatistics({
+            segImageIds,
+            indices,
+            unit,
+            mode,
+        });
     return stats;
 }
-async function calculateVolumeStatistics(operationData, indices, unit) {
+async function calculateVolumeStatistics({ operationData, indices, unit, mode, }) {
     const strategyData = getStrategyData({
         operationData,
         strategy: {
@@ -87,8 +97,33 @@ async function calculateVolumeStatistics(operationData, indices, unit) {
         segmentationInfo,
         imageInfo,
         indices,
+        mode,
     });
     triggerWorkerProgress(eventTarget, 100);
+    if (mode === 'collective') {
+        return processSegmentationStatistics({
+            stats,
+            unit,
+            spacing,
+            segmentationImageData,
+            imageVoxelManager,
+        });
+    }
+    else {
+        const finalStats = {};
+        Object.entries(stats).forEach(([segmentIndex, stat]) => {
+            finalStats[segmentIndex] = processSegmentationStatistics({
+                stats: stat,
+                unit,
+                spacing,
+                segmentationImageData,
+                imageVoxelManager,
+            });
+        });
+        return finalStats;
+    }
+}
+const processSegmentationStatistics = ({ stats, unit, spacing, segmentationImageData, imageVoxelManager, }) => {
     stats.mean.unit = unit;
     stats.max.unit = unit;
     stats.min.unit = unit;
@@ -112,8 +147,8 @@ async function calculateVolumeStatistics(operationData, indices, unit) {
         }
     }
     return stats;
-}
-async function calculateStackStatistics(segImageIds, indices, unit) {
+};
+async function calculateStackStatistics({ segImageIds, indices, unit, mode }) {
     triggerWorkerProgress(eventTarget, 0);
     const segmentationInfo = [];
     const imageInfo = [];
@@ -142,12 +177,34 @@ async function calculateStackStatistics(segImageIds, indices, unit) {
         segmentationInfo,
         imageInfo,
         indices,
+        mode,
     });
     triggerWorkerProgress(eventTarget, 100);
-    stats.mean.unit = unit;
-    stats.max.unit = unit;
-    stats.min.unit = unit;
-    return stats;
+    const spacing = segmentationInfo[0].spacing;
+    const segmentationImageData = segmentationInfo[0];
+    const imageVoxelManager = imageInfo[0].voxelManager;
+    if (mode === 'collective') {
+        return processSegmentationStatistics({
+            stats,
+            unit,
+            spacing,
+            segmentationImageData,
+            imageVoxelManager,
+        });
+    }
+    else {
+        const finalStats = {};
+        Object.entries(stats).forEach(([segmentIndex, stat]) => {
+            finalStats[segmentIndex] = processSegmentationStatistics({
+                stats: stat,
+                unit,
+                spacing,
+                segmentationImageData,
+                imageVoxelManager,
+            });
+        });
+        return finalStats;
+    }
 }
 function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
     const { pointIJK: centerIJK } = testMax;

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

@@ -7,6 +7,7 @@ import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
 import VolumetricCalculator from './VolumetricCalculator';
+import SegmentStatsCalculator from './SegmentStatsCalculator';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
@@ -25,4 +26,4 @@ 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, };
+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, };

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

@@ -7,6 +7,7 @@ import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
 import VolumetricCalculator from './VolumetricCalculator';
+import SegmentStatsCalculator from './SegmentStatsCalculator';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
@@ -25,4 +26,4 @@ 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, };
+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, };

package/dist/esm/workers/computeWorker.js

@@ -1,10 +1,10 @@
 import { expose } from 'comlink';
 import { utilities } from '@cornerstonejs/core';
-import VolumetricCalculator from '../utilities/segmentation/VolumetricCalculator';
+import SegmentStatsCalculator from '../utilities/segmentation/SegmentStatsCalculator';
 const { VoxelManager } = utilities;
 const computeWorker = {
     calculateSegmentsStatisticsVolume: (args) => {
-        const { segmentationInfo, imageInfo, indices } = args;
+        const { segmentationInfo, imageInfo, indices, mode } = args;
         const { scalarData: segmentationScalarData, dimensions: segmentationDimensions, spacing: segmentationSpacing, } = segmentationInfo;
         const { scalarData: imageScalarData, dimensions: imageDimensions } = imageInfo;
         if (segmentationDimensions[0] !== imageDimensions[0] ||
@@ -20,26 +20,30 @@ const computeWorker = {
             dimensions: imageDimensions,
             scalarData: imageScalarData,
         });
+        SegmentStatsCalculator.statsInit({ storePointData: false, indices, mode });
         segVoxelManager.forEach(({ value, pointIJK, index }) => {
             if (indices.indexOf(value) === -1) {
                 return;
             }
             const imageValue = imageVoxelManager.getAtIndex(index);
-            VolumetricCalculator.statsCallback({
+            SegmentStatsCalculator.statsCallback({
+                segmentIndex: value,
                 value: imageValue,
                 pointIJK,
             });
         }, {
             boundsIJK: imageVoxelManager.getDefaultBounds(),
         });
-        const stats = VolumetricCalculator.getStatistics({
+        const stats = SegmentStatsCalculator.getStatistics({
             spacing: segmentationSpacing,
             unit: 'mm',
+            mode,
         });
         return stats;
     },
     calculateSegmentsStatisticsStack: (args) => {
-        const { segmentationInfo, imageInfo, indices } = args;
+        const { segmentationInfo, imageInfo, indices, mode } = args;
+        SegmentStatsCalculator.statsInit({ storePointData: true, indices, mode });
         for (let i = 0; i < segmentationInfo.length; i++) {
             const segInfo = segmentationInfo[i];
             const imgInfo = imageInfo[i];
@@ -61,16 +65,19 @@ const computeWorker = {
                     return;
                 }
                 const imageValue = imageVoxelManager.getAtIndex(index);
-                VolumetricCalculator.statsCallback({
+                SegmentStatsCalculator.statsCallback({
+                    segmentIndex: value,
                     value: imageValue,
+                    pointIJK,
                 });
             }, {
                 boundsIJK: imageVoxelManager.getDefaultBounds(),
             });
         }
         const spacing = segmentationInfo[0].spacing;
-        const stats = VolumetricCalculator.getStatistics({
+        const stats = SegmentStatsCalculator.getStatistics({
             spacing,
+            mode,
         });
         return stats;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.1.1",
+    "@cornerstonejs/core": "^3.2.0",
     "@kitware/vtk.js": "32.9.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "91a215bf75b76f6cbd017a811b5dfcff60f7f060"
+  "gitHead": "ee69f78b449fce9b37702ad5e158d6764d00aff9"
 }