@cornerstonejs/tools 3.6.0 → 3.7.0

package/dist/esm/tools/annotation/AngleTool.d.ts

@@ -19,6 +19,10 @@ declare class AngleTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: AngleTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => AngleAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => AngleAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: AngleAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

package/dist/esm/tools/annotation/AngleTool.js

@@ -390,11 +390,7 @@ class AngleTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(AngleTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/ArrowAnnotateTool.d.ts

@@ -18,6 +18,10 @@ declare class ArrowAnnotateTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], text?: string, options?: {
         annotationUID?: string;
+        toolInstance?: ArrowAnnotateTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => ArrowAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => ArrowAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: ArrowAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

package/dist/esm/tools/annotation/ArrowAnnotateTool.js

@@ -392,11 +392,7 @@ class ArrowAnnotateTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(ArrowAnnotateTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/BidirectionalTool.d.ts

@@ -20,6 +20,10 @@ declare class BidirectionalTool extends AnnotationTool {
     addNewAnnotation(evt: EventTypes.InteractionEventType): BidirectionalAnnotation;
     static hydrate: (viewportId: string, axis: [[Types.Point3, Types.Point3], [Types.Point3, Types.Point3]], options?: {
         annotationUID?: string;
+        toolInstance?: BidirectionalTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => BidirectionalAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: BidirectionalAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: BidirectionalAnnotation) => void;

package/dist/esm/tools/annotation/BidirectionalTool.js

@@ -714,22 +714,29 @@ class BidirectionalTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(BidirectionalTool, enabledElement, [], options);
         const [majorAxis, minorAxis] = axis;
         const [major0, major1] = majorAxis;
         const [minor0, minor1] = minorAxis;
         const points = [major0, major1, minor0, minor1];
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
                 handles: {
                     points,
                     activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
                 },
+                cachedStats: {},
             },
             highlighted: false,
             autoGenerated: false,
@@ -746,6 +753,7 @@ class BidirectionalTool extends AnnotationTool {
         };
         addAnnotation(annotation, viewport.element);
         triggerAnnotationRenderForViewportIds([viewport.id]);
+        return annotation;
     }; }
     _calculateLength(pos1, pos2) {
         const dx = pos1[0] - pos2[0];

package/dist/esm/tools/annotation/CircleROITool.d.ts

@@ -34,6 +34,10 @@ declare class CircleROITool extends AnnotationTool {
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: CircleROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => CircleROIAnnotation;
 }
 export default CircleROITool;

package/dist/esm/tools/annotation/CircleROITool.js

@@ -570,11 +570,7 @@ class CircleROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(CircleROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/EllipticalROITool.d.ts

@@ -22,6 +22,10 @@ declare class EllipticalROITool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: EllipticalROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => EllipticalROIAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => EllipticalROIAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: EllipticalROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

package/dist/esm/tools/annotation/EllipticalROITool.js

@@ -636,11 +636,7 @@ class EllipticalROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(EllipticalROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/LengthTool.d.ts

@@ -18,6 +18,10 @@ declare class LengthTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: LengthTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => LengthAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => LengthAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: LengthAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;

package/dist/esm/tools/annotation/LengthTool.js

@@ -361,11 +361,7 @@ class LengthTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(LengthTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {

package/dist/esm/tools/annotation/ProbeTool.d.ts

@@ -19,6 +19,10 @@ declare class ProbeTool extends AnnotationTool {
     toolSelectedCallback(): void;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: ProbeTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => ProbeAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => ProbeAnnotation;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: ProbeAnnotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;

package/dist/esm/tools/annotation/ProbeTool.js

@@ -224,11 +224,7 @@ class ProbeTool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(ProbeTool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/RectangleROITool.d.ts

@@ -38,6 +38,10 @@ declare class RectangleROITool extends AnnotationTool {
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
+        toolInstance?: RectangleROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => RectangleROIAnnotation;
 }
 export default RectangleROITool;

package/dist/esm/tools/annotation/RectangleROITool.js

@@ -521,11 +521,7 @@ class RectangleROITool extends AnnotationTool {
         if (!enabledElement) {
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(RectangleROITool, enabledElement, points, options);
         const annotation = {
             annotationUID: options?.annotationUID || csUtils.uuidv4(),
             data: {

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -68,6 +68,10 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
         splineType?: SplineTypesEnum;
+        toolInstance?: SplineROITool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => SplineROIAnnotation;
 }
 export default SplineROITool;

package/dist/esm/tools/annotation/SplineROITool.js

@@ -726,19 +726,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
             console.warn('Spline requires at least 3 control points');
             return;
         }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(SplineROITool, enabledElement, points, options);
         const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
         const splineConfig = instance._getSplineConfig(splineType);
         const SplineClass = splineConfig.Class;
         const splineInstance = new SplineClass();
-        const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
-        splineInstance.setControlPoints(canvasPoints);
-        const splinePolylineCanvas = splineInstance.getPolylinePoints();
-        const splinePolylineWorld = splinePolylineCanvas.map((point) => viewport.canvasToWorld(point));
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
@@ -753,7 +745,6 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 },
                 contour: {
                     closed: true,
-                    polyline: splinePolylineWorld,
                 },
             },
             highlighted: false,

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -1,3 +1,4 @@
+import { StackViewport } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
@@ -54,5 +55,19 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
         restoreMemo: () => void;
     };
     protected createMemo(element: any, annotation: any, options?: any): void;
+    protected static hydrateBase<T extends AnnotationTool>(ToolClass: new () => T, enabledElement: Types.IEnabledElement, points: Types.Point3[], options?: {
+        annotationUID?: string;
+        toolInstance?: T;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
+    }): {
+        FrameOfReferenceUID: string;
+        referencedImageId: any;
+        viewPlaneNormal: Types.Point3;
+        viewUp: Types.Point3;
+        instance: T;
+        viewport: StackViewport | import("@cornerstonejs/core").VolumeViewport;
+    };
 }
 export default AnnotationTool;

package/dist/esm/tools/base/AnnotationTool.js

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, cache, getEnabledElement, metaData, utilities as csUtils, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, metaData, utilities as csUtils, StackViewport, } from '@cornerstonejs/core';
 import { vec2 } from 'gl-matrix';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -266,6 +266,47 @@ class AnnotationTool extends AnnotationDisplayTool {
     createMemo(element, annotation, options) {
         this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
     }
+    static hydrateBase(ToolClass, enabledElement, points, options = {}) {
+        if (!enabledElement) {
+            return null;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const camera = viewport.getCamera();
+        const viewPlaneNormal = options.viewplaneNormal ?? camera.viewPlaneNormal;
+        const viewUp = options.viewUp ?? camera.viewUp;
+        const instance = options.toolInstance || new ToolClass();
+        let referencedImageId;
+        let finalViewPlaneNormal = viewPlaneNormal;
+        let finalViewUp = viewUp;
+        if (options.referencedImageId) {
+            referencedImageId = options.referencedImageId;
+            finalViewPlaneNormal = undefined;
+            finalViewUp = undefined;
+        }
+        else {
+            if (viewport instanceof StackViewport) {
+                const closestImageIndex = csUtils.getClosestStackImageIndexForPoint(points[0], viewport);
+                if (closestImageIndex) {
+                    referencedImageId = viewport.getImageIds()[closestImageIndex];
+                }
+            }
+            else if (viewport instanceof BaseVolumeViewport) {
+                referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+            }
+            else {
+                throw new Error('Unsupported viewport type');
+            }
+        }
+        return {
+            FrameOfReferenceUID,
+            referencedImageId,
+            viewPlaneNormal: finalViewPlaneNormal,
+            viewUp: finalViewUp,
+            instance,
+            viewport,
+        };
+    }
 }
 AnnotationTool.toolName = 'AnnotationTool';
 export default AnnotationTool;

package/dist/esm/tools/segmentation/SegmentBidirectionalTool.d.ts

@@ -21,6 +21,10 @@ declare class SegmentBidirectionalTool extends BidirectionalTool {
         segmentIndex?: number;
         segmentationId?: string;
         annotationUID?: string;
+        toolInstance?: SegmentBidirectionalTool;
+        referencedImageId?: string;
+        viewplaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
     }) => SegmentBidirectionalAnnotation;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
 }

package/dist/esm/tools/segmentation/SegmentBidirectionalTool.js

@@ -201,8 +201,6 @@ class SegmentBidirectionalTool extends BidirectionalTool {
             return;
         }
         const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
         const existingAnnotations = getAllAnnotations();
         const toolAnnotations = existingAnnotations.filter((annotation) => annotation.metadata.toolName === 'SegmentBidirectional');
         const existingAnnotation = toolAnnotations.find((annotation) => {
@@ -216,19 +214,29 @@ class SegmentBidirectionalTool extends BidirectionalTool {
         if (existingAnnotation) {
             removeAnnotation(existingAnnotation.annotationUID);
         }
-        const instance = new this();
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, } = this.hydrateBase(SegmentBidirectionalTool, enabledElement, axis[0], options);
         const [majorAxis, minorAxis] = axis;
         const [major0, major1] = majorAxis;
         const [minor0, minor1] = minorAxis;
         const points = [major0, major1, minor0, minor1];
-        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
         const annotation = {
             annotationUID: options?.annotationUID || utilities.uuidv4(),
             data: {
                 handles: {
                     points,
                     activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
                 },
+                cachedStats: {},
             },
             highlighted: false,
             autoGenerated: false,

package/dist/esm/tools/segmentation/strategies/compositions/ensureImageVolume.js

@@ -1,6 +1,7 @@
-import { cache, utilities as csUtils, volumeLoader } from '@cornerstonejs/core';
+import { cache, utilities as csUtils } from '@cornerstonejs/core';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import getOrCreateImageVolume from '../../../../utilities/segmentation/getOrCreateImageVolume';
 export default {
     [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: (data) => {
         const { operationData, viewport } = data;
@@ -21,14 +22,10 @@ export default {
                 return image.referencedImageId;
             });
         }
-        const volumeId = cache.generateVolumeId(referencedImageIds);
-        let imageVolume = cache.getVolume(volumeId);
-        if (imageVolume) {
-            operationData.imageVoxelManager = imageVolume.voxelManager;
-            operationData.imageData = imageVolume.imageData;
-            return;
+        const imageVolume = getOrCreateImageVolume(referencedImageIds);
+        if (!imageVolume) {
+            throw new Error('Failed to create or get image volume');
         }
-        imageVolume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds);
         operationData.imageVoxelManager = imageVolume.voxelManager;
         operationData.imageData = imageVolume.imageData;
     },

package/dist/esm/types/CalculatorTypes.d.ts

@@ -45,6 +45,12 @@ type NamedStatistics = {
     lesionGlycolysis?: Statistics & {
         name: 'lesionGlycolysis';
     };
+    maxLPS?: Statistics & {
+        name: 'maxLPS';
+    };
+    minLPS?: Statistics & {
+        name: 'minLPS';
+    };
     maxIJKs?: Array<{
         value: number;
         pointIJK: Types.Point3;

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

@@ -55,15 +55,15 @@ function basicStatsCallback(state, newValue, pointLPS = null, pointIJK = null) {
         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;
             }
         }
     });
@@ -105,16 +105,16 @@ function basicGetStatistics(state, unit) {
             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',
@@ -152,10 +152,22 @@ function basicGetStatistics(state, unit) {
             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.median, named.skewness, named.kurtosis, 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;

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

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/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/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, utilities } from '@cornerstonejs/core';
+import { cache, volumeLoader, utilities, } from '@cornerstonejs/core';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getOrCreateSegmentationVolume(segmentationId) {
     const { representationData } = getSegmentation(segmentationId);

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

@@ -116,7 +116,14 @@ const processSegmentationStatistics = ({ stats, unit, spacing, segmentationImage
                 value: mean.value,
                 unit,
             };
+            stats.peakPoint = {
+                name: 'peakLPS',
+                label: 'Peak SUV Point',
+                value: testMax.pointLPS ? [...testMax.pointLPS] : null,
+                unit: null,
+            };
             updateStatsArray(stats, stats.peakValue);
+            updateStatsArray(stats, stats.peakPoint);
         }
     }
     if (stats.volume && stats.mean) {
@@ -169,7 +176,7 @@ async function calculateStackStatistics({ segImageIds, indices, unit, mode }) {
     }
 }
 function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
-    const { pointIJK: centerIJK } = testMax;
+    const { pointIJK: centerIJK, pointLPS: centerLPS } = testMax;
     if (!centerIJK) {
         return;
     }

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

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

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

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

package/dist/esm/workers/computeWorker.js

@@ -29,15 +29,24 @@ const computeWorker = {
             scalarData,
         };
     },
-    createVTKImageData: (dimensions, origin, direction, spacing) => {
+    createVTKImageData: (dimensions, origin, direction, spacing, scalarData) => {
         const imageData = vtkImageData.newInstance();
         imageData.setDimensions(dimensions);
         imageData.setOrigin(origin);
         imageData.setDirection(direction);
         imageData.setSpacing(spacing);
+        if (!scalarData) {
+            return imageData;
+        }
+        const scalarArray = vtkDataArray.newInstance({
+            name: 'Scalars',
+            numberOfComponents: 1,
+            values: scalarData,
+        });
+        imageData.getPointData().setScalars(scalarArray);
         return imageData;
     },
-    processSegmentStatistics: (segVoxelManager, imageVoxelManager, indices, bounds) => {
+    processSegmentStatistics: ({ segVoxelManager, imageVoxelManager, indices, bounds, imageData, }) => {
         segVoxelManager.forEach(({ value, pointIJK, pointLPS, index }) => {
             if (indices.indexOf(value) === -1) {
                 return;
@@ -51,6 +60,7 @@ const computeWorker = {
             });
         }, {
             boundsIJK: bounds || imageVoxelManager.getDefaultBounds(),
+            imageData,
         });
     },
     performMarchingSquares: (imageData, sliceIndex = null, slicingMode = null) => {
@@ -99,8 +109,14 @@ const computeWorker = {
         const { segmentation, image } = computeWorker.getArgsFromInfo(args);
         const { voxelManager: segVoxelManager, spacing: segmentationSpacing } = segmentation;
         const { voxelManager: imageVoxelManager } = image;
+        const imageData = computeWorker.createVTKImageData(segmentation.dimensions, segmentation.origin, segmentation.direction, segmentation.spacing);
         SegmentStatsCalculator.statsInit({ storePointData: false, indices, mode });
-        computeWorker.processSegmentStatistics(segVoxelManager, imageVoxelManager, indices);
+        computeWorker.processSegmentStatistics({
+            segVoxelManager,
+            imageVoxelManager,
+            indices,
+            imageData,
+        });
         const stats = SegmentStatsCalculator.getStatistics({
             spacing: segmentationSpacing,
             unit: 'mm',
@@ -108,6 +124,33 @@ const computeWorker = {
         });
         return stats;
     },
+    computeMetabolicStats({ segmentationInfo, imageInfo }) {
+        const { scalarData, dimensions, spacing, origin, direction } = segmentationInfo;
+        const { spacing: imageSpacing, dimensions: imageDimensions, direction: imageDirection, origin: imageOrigin, scalarData: imageScalarData, } = imageInfo;
+        const segVoxelManager = computeWorker.createVoxelManager(segmentationInfo.dimensions, segmentationInfo.scalarData);
+        const refVoxelManager = computeWorker.createVoxelManager(imageDimensions, imageScalarData);
+        let suv = 0;
+        let numVoxels = 0;
+        const scalarDataLength = segVoxelManager.getScalarDataLength();
+        for (let i = 0; i < scalarDataLength; i++) {
+            if (segVoxelManager.getAtIndex(i) !== 0) {
+                suv += refVoxelManager.getAtIndex(i);
+                numVoxels++;
+            }
+        }
+        const tmtv = 1e-3 * numVoxels * spacing[0] * spacing[1] * spacing[2];
+        const averageSuv = numVoxels > 0 ? suv / numVoxels : 0;
+        const tlg = averageSuv *
+            numVoxels *
+            imageSpacing[0] *
+            imageSpacing[1] *
+            imageSpacing[2] *
+            1e-3;
+        return {
+            tmtv,
+            tlg,
+        };
+    },
     calculateSegmentsStatisticsStack: (args) => {
         const { segmentationInfo, imageInfo, indices, mode } = args;
         SegmentStatsCalculator.statsInit({ storePointData: true, indices, mode });
@@ -121,7 +164,13 @@ const computeWorker = {
             ];
             const segVoxelManager = computeWorker.createVoxelManager(segDimensions, segInfo.scalarData);
             const imageVoxelManager = computeWorker.createVoxelManager(segDimensions, imgInfo.scalarData);
-            computeWorker.processSegmentStatistics(segVoxelManager, imageVoxelManager, indices);
+            const imageData = computeWorker.createVTKImageData(segDimensions, segInfo.origin, segInfo.direction, segInfo.spacing);
+            computeWorker.processSegmentStatistics({
+                segVoxelManager,
+                imageVoxelManager,
+                indices,
+                imageData,
+            });
         }
         const spacing = segmentationInfo[0].spacing;
         const stats = SegmentStatsCalculator.getStatistics({
@@ -141,58 +190,119 @@ const computeWorker = {
                 segmentationInfo: segmentationInfo[0],
             }));
         }
-        const { voxelManager, dimensions, origin, direction, spacing } = segmentation;
-        const stackDimensions = isStack
-            ? [dimensions[0], dimensions[1], 2]
-            : dimensions;
-        const stackSpacing = isStack ? [spacing[0], spacing[1], 1] : spacing;
-        const imageData = computeWorker.createVTKImageData(stackDimensions, origin, direction, stackSpacing);
-        let contourSets;
-        if (!isStack) {
-            contourSets = computeWorker.generateContourSetsFromLabelmapVolume({
-                segmentation,
+        return isStack
+            ? computeWorker.calculateBidirectionalStack({
+                segmentationInfo,
                 indices,
-                imageData,
                 mode,
-            });
-        }
-        else {
-            contourSets = computeWorker.generateContourSetsFromLabelmapStack({
-                segmentationInfo,
+            })
+            : computeWorker.calculateVolumetricBidirectional({
+                segmentation,
                 indices,
                 mode,
             });
+    },
+    findLargestBidirectionalFromContours: (contours, isInSegment, segmentIndex) => {
+        let maxBidirectional;
+        for (const sliceContour of contours) {
+            const bidirectional = createBidirectionalForSlice(sliceContour, isInSegment, maxBidirectional);
+            if (!bidirectional) {
+                continue;
+            }
+            maxBidirectional = bidirectional;
         }
-        const bidirectionalData = [];
+        if (maxBidirectional) {
+            return {
+                segmentIndex,
+                majorAxis: maxBidirectional.majorAxis,
+                minorAxis: maxBidirectional.minorAxis,
+                maxMajor: maxBidirectional.maxMajor,
+                maxMinor: maxBidirectional.maxMinor,
+            };
+        }
+        return null;
+    },
+    calculateBidirectionalStack: ({ segmentationInfo, indices, mode }) => {
+        const segments = computeWorker.createSegmentsFromIndices(indices);
+        let bidirectionalResults = [];
+        for (let i = 0; i < segmentationInfo.length; i++) {
+            const segInfo = segmentationInfo[i];
+            const dimensions = segInfo.dimensions;
+            const segScalarData = segInfo.scalarData;
+            const { spacing, direction, origin } = segInfo;
+            const voxelManager = computeWorker.createVoxelManager(dimensions, segScalarData);
+            const pixelsPerSlice = dimensions[0] * dimensions[1];
+            for (let segIndex = 1; segIndex < segments.length; segIndex++) {
+                const segment = segments[segIndex];
+                if (!segment) {
+                    continue;
+                }
+                const segmentIndex = segment.segmentIndex;
+                if (computeWorker.isSliceEmptyForSegmentVolume(0, segScalarData, pixelsPerSlice, segmentIndex)) {
+                    continue;
+                }
+                const sliceContours = [];
+                const filteredData = new Uint8Array(segScalarData.length);
+                for (let i = 0; i < segScalarData.length; i++) {
+                    filteredData[i] = segScalarData[i] === segmentIndex ? 1 : 0;
+                }
+                const scalarArray = vtkDataArray.newInstance({
+                    name: 'Pixels',
+                    numberOfComponents: 1,
+                    values: filteredData,
+                });
+                const imageData = computeWorker.createVTKImageData(dimensions, origin, direction, [spacing[0], spacing[1], 1]);
+                imageData.getPointData().setScalars(scalarArray);
+                try {
+                    const msOutput = computeWorker.performMarchingSquares(imageData, null, 2);
+                    const contourData = computeWorker.createContoursFromPolyData(msOutput);
+                    if (contourData) {
+                        sliceContours.push(contourData);
+                    }
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                const isInSegment = createIsInSegmentMetadata({
+                    dimensions,
+                    imageData,
+                    voxelManager,
+                    segmentIndex,
+                });
+                const bidirectionalResult = computeWorker.findLargestBidirectionalFromContours(sliceContours, isInSegment, segmentIndex);
+                if (bidirectionalResult) {
+                    bidirectionalResults.push(bidirectionalResult);
+                }
+            }
+        }
+        return bidirectionalResults;
+    },
+    calculateVolumetricBidirectional: ({ segmentation, indices, mode }) => {
+        const { voxelManager, dimensions, origin, direction, spacing } = segmentation;
+        const imageData = computeWorker.createVTKImageData(dimensions, origin, direction, spacing);
+        const contourSets = computeWorker.generateContourSetsFromLabelmapVolume({
+            segmentation,
+            indices,
+            imageData,
+            mode,
+        });
+        const bidirectionalResults = [];
         for (let i = 0; i < contourSets.length; i++) {
             const contourSet = contourSets[i];
             const { segmentIndex } = contourSet.segment;
             const contours = contourSet.sliceContours;
-            let maxBidirectional;
             const isInSegment = createIsInSegmentMetadata({
                 dimensions,
                 imageData,
                 voxelManager,
                 segmentIndex,
             });
-            for (const sliceContour of contours) {
-                const bidirectional = createBidirectionalForSlice(sliceContour, isInSegment, maxBidirectional);
-                if (!bidirectional) {
-                    continue;
-                }
-                maxBidirectional = bidirectional;
-            }
-            if (maxBidirectional) {
-                bidirectionalData.push({
-                    segmentIndex,
-                    majorAxis: maxBidirectional.majorAxis,
-                    minorAxis: maxBidirectional.minorAxis,
-                    maxMajor: maxBidirectional.maxMajor,
-                    maxMinor: maxBidirectional.maxMinor,
-                });
+            const bidirectionalResult = computeWorker.findLargestBidirectionalFromContours(contours, isInSegment, segmentIndex);
+            if (bidirectionalResult) {
+                bidirectionalResults.push(bidirectionalResult);
             }
         }
-        return bidirectionalData;
+        return bidirectionalResults;
     },
     generateContourSetsFromLabelmapVolume: (args) => {
         const { segmentation, indices, imageData } = args;
@@ -259,62 +369,6 @@ const computeWorker = {
         }
         return ContourSets;
     },
-    generateContourSetsFromLabelmapStack: (args) => {
-        const { segmentationInfo, indices } = args;
-        let ContourSets = [];
-        for (let i = 0; i < segmentationInfo.length; i++) {
-            const segInfo = segmentationInfo[i];
-            const dimensions = segInfo.dimensions;
-            const segScalarData = segInfo.scalarData;
-            const { spacing, direction, origin } = segInfo;
-            const segments = computeWorker.createSegmentsFromIndices(indices);
-            const pixelsPerSlice = dimensions[0] * dimensions[1];
-            const numSegments = segments.length;
-            for (let segIndex = 0; segIndex < numSegments; segIndex++) {
-                const segment = segments[segIndex];
-                if (!segment) {
-                    continue;
-                }
-                const segmentIndex = segment.segmentIndex;
-                if (computeWorker.isSliceEmptyForSegmentVolume(0, segScalarData, pixelsPerSlice, segmentIndex)) {
-                    continue;
-                }
-                const sliceContours = [];
-                const filteredData = new Uint8Array(segScalarData.length);
-                for (let i = 0; i < segScalarData.length; i++) {
-                    if (segScalarData[i] === segmentIndex) {
-                        filteredData[i] = 1;
-                    }
-                    else {
-                        filteredData[i] = 0;
-                    }
-                }
-                const scalarArray = vtkDataArray.newInstance({
-                    name: 'Pixels',
-                    numberOfComponents: 1,
-                    values: filteredData,
-                });
-                const imageData = computeWorker.createVTKImageData(dimensions, origin, direction, [spacing[0], spacing[1], 1]);
-                imageData.getPointData().setScalars(scalarArray);
-                try {
-                    const msOutput = computeWorker.performMarchingSquares(imageData, null, 2);
-                    const contourData = computeWorker.createContoursFromPolyData(msOutput);
-                    if (contourData) {
-                        sliceContours.push(contourData);
-                    }
-                }
-                catch (e) {
-                    console.warn(e);
-                }
-                const ContourSet = {
-                    sliceContours,
-                    segment,
-                };
-                ContourSets.push(ContourSet);
-            }
-        }
-        return ContourSets;
-    },
     isSliceEmptyForSegmentVolume: (sliceIndex, segData, pixelsPerSlice, segIndex) => {
         const startIdx = sliceIndex * pixelsPerSlice;
         const endIdx = startIdx + pixelsPerSlice;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,8 +103,8 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.6.0",
-    "@kitware/vtk.js": "32.12.0",
+    "@cornerstonejs/core": "^3.7.0",
+    "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
     "d3-array": "^3.2.3",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "480e48c2a25ce79a4a90be6fe180d1bcdd1b831e"
+  "gitHead": "177fce2dd8c2278d3c8473f15df795e757d40b7e"
 }