@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/utilities/dynamicVolume/generateImageFromTimeData.js

@@ -1,43 +1,77 @@
 import { Enums } from '@cornerstonejs/core';
-function generateImageFromTimeData(dynamicVolume, operation, frameNumbers) {
-    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
-    const numFrames = frames.length;
-    if (frames.length <= 1) {
-        throw new Error('Please provide two or more time points');
-    }
-    const typedArrays = dynamicVolume.getScalarDataArrays();
-    const arrayLength = typedArrays[0].length;
-    const finalArray = new Float32Array(arrayLength);
-    if (operation === Enums.DynamicOperatorType.SUM) {
-        for (let i = 0; i < numFrames; i++) {
-            const currentArray = typedArrays[frames[i]];
-            for (let j = 0; j < arrayLength; j++) {
-                finalArray[j] += currentArray[j];
+const operationFunctions = {
+    [Enums.GenerateImageType.SUM]: (voxelManager, frames, callback) => {
+        const arrayLength = voxelManager.getScalarDataLength();
+        for (let j = 0; j < arrayLength; j++) {
+            let sum = 0;
+            for (const timepoint of frames) {
+                sum += voxelManager.getAtIndexAndTimePoint(j, timepoint);
             }
+            callback(j, sum);
         }
-        return finalArray;
-    }
-    if (operation === Enums.DynamicOperatorType.SUBTRACT) {
-        if (frames.length > 2) {
+    },
+    [Enums.GenerateImageType.SUBTRACT]: (voxelManager, frames, callback) => {
+        if (frames.length !== 2) {
             throw new Error('Please provide only 2 time points for subtraction.');
         }
+        const arrayLength = voxelManager.getScalarDataLength();
         for (let j = 0; j < arrayLength; j++) {
-            finalArray[j] += typedArrays[frames[0]][j] - typedArrays[frames[1]][j];
+            const difference = voxelManager.getAtIndexAndTimePoint(j, frames[0]) -
+                voxelManager.getAtIndexAndTimePoint(j, frames[1]);
+            callback(j, difference);
         }
-        return finalArray;
-    }
-    if (operation === Enums.DynamicOperatorType.AVERAGE) {
-        for (let i = 0; i < numFrames; i++) {
-            const currentArray = typedArrays[frames[i]];
-            for (let j = 0; j < arrayLength; j++) {
-                finalArray[j] += currentArray[j];
+    },
+    [Enums.GenerateImageType.AVERAGE]: (voxelManager, frames, callback) => {
+        const arrayLength = voxelManager.getScalarDataLength();
+        for (let j = 0; j < arrayLength; j++) {
+            let sum = 0;
+            for (const timepoint of frames) {
+                sum += voxelManager.getAtIndexAndTimePoint(j, timepoint);
             }
+            const average = sum / frames.length;
+            callback(j, average);
         }
-        for (let k = 0; k < arrayLength; k++) {
-            finalArray[k] = finalArray[k] / numFrames;
-        }
-        return finalArray;
+    },
+};
+function generateImageFromTimeData(dynamicVolume, operation, options) {
+    const { frameNumbers } = options;
+    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
+    if (frames.length <= 1) {
+        throw new Error('Please provide two or more time points');
+    }
+    const voxelManager = dynamicVolume.voxelManager;
+    const arrayLength = voxelManager.getScalarDataLength();
+    const operationFunction = operationFunctions[operation];
+    if (!operationFunction) {
+        throw new Error(`Unsupported operation: ${operation}`);
+    }
+    const resultArray = new Float32Array(arrayLength);
+    operationFunction(voxelManager, frames, (index, value) => {
+        resultArray[index] = value;
+    });
+    return resultArray;
+}
+function updateVolumeFromTimeData(dynamicVolume, operation, options) {
+    const { frameNumbers, targetVolume } = options;
+    if (!targetVolume) {
+        throw new Error('A target volume must be provided');
+    }
+    const frames = frameNumbers || [...Array(dynamicVolume.numTimePoints).keys()];
+    if (frames.length <= 1) {
+        throw new Error('Please provide two or more time points');
+    }
+    const voxelManager = dynamicVolume.voxelManager;
+    const targetVoxelManager = targetVolume.voxelManager;
+    const operationFunction = operationFunctions[operation];
+    if (!operationFunction) {
+        throw new Error(`Unsupported operation: ${operation}`);
+    }
+    operationFunction(voxelManager, frames, (index, value) => {
+        targetVoxelManager.setAtIndex(index, value);
+    });
+    targetVoxelManager.resetModifiedSlices();
+    for (let k = 0; k < targetVolume.dimensions[2]; k++) {
+        targetVoxelManager.modifiedSlices.add(k);
     }
 }
-export default generateImageFromTimeData;
-//# sourceMappingURL=generateImageFromTimeData.js.map
+export { generateImageFromTimeData, updateVolumeFromTimeData };

package/dist/esm/utilities/dynamicVolume/getDataInTime.d.ts

@@ -1,7 +1,7 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function getDataInTime(dynamicVolume: Types.IDynamicImageVolume, options: {
     frameNumbers?: any;
     maskVolumeId?: any;
-    imageCoordinate?: any;
+    worldCoordinate?: any;
 }): number[] | number[][];
 export default getDataInTime;

package/dist/esm/utilities/dynamicVolume/getDataInTime.js

@@ -1,29 +1,23 @@
 import { utilities, cache } from '@cornerstonejs/core';
+import { getVoxelOverlap } from '../segmentation/utilities';
 function getDataInTime(dynamicVolume, options) {
     let dataInTime;
     const frames = options.frameNumbers || [
         ...Array(dynamicVolume.numTimePoints).keys(),
     ];
-    if (!options.maskVolumeId && !options.imageCoordinate) {
-        throw new Error('No ROI provided');
+    if (!options.maskVolumeId && !options.worldCoordinate) {
+        throw new Error('You should provide either maskVolumeId or imageCoordinate');
     }
-    if (options.maskVolumeId && options.imageCoordinate) {
-        throw new Error('Please provide only one ROI');
+    if (options.maskVolumeId && options.worldCoordinate) {
+        throw new Error('You can only use one of maskVolumeId or imageCoordinate');
     }
     if (options.maskVolumeId) {
         const segmentationVolume = cache.getVolume(options.maskVolumeId);
-        const segScalarData = segmentationVolume.getScalarData();
-        const indexArray = [];
-        for (let i = 0, len = segScalarData.length; i < len; i++) {
-            if (segScalarData[i] !== 0) {
-                indexArray.push(i);
-            }
-        }
-        const dataInTime = _getTimePointDataMask(frames, indexArray, dynamicVolume);
-        return dataInTime;
+        const [dataInTime, ijkCoords] = _getTimePointDataMask(frames, dynamicVolume, segmentationVolume);
+        return [dataInTime, ijkCoords];
     }
-    if (options.imageCoordinate) {
-        const dataInTime = _getTimePointDataCoordinate(frames, options.imageCoordinate, dynamicVolume);
+    if (options.worldCoordinate) {
+        const dataInTime = _getTimePointDataCoordinate(frames, options.worldCoordinate, dynamicVolume);
         return dataInTime;
     }
     return dataInTime;
@@ -48,18 +42,73 @@ function _getTimePointDataCoordinate(frames, coordinate, volume) {
     });
     return value;
 }
-function _getTimePointDataMask(frames, indexArray, volume) {
-    const allScalarData = volume.getScalarDataArrays();
-    const value = [];
-    for (let i = 0; i < indexArray.length; i++) {
-        const indexValues = [];
-        frames.forEach((frame) => {
-            const activeScalarData = allScalarData[frame];
-            indexValues.push(activeScalarData[indexArray[i]]);
-        });
-        value.push(indexValues);
+function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
+    const { imageData: maskImageData } = segmentationVolume;
+    const segVoxelManager = segmentationVolume.voxelManager;
+    const scalarDataLength = segVoxelManager.getScalarDataLength();
+    const nonZeroVoxelIndices = [];
+    nonZeroVoxelIndices.length = scalarDataLength;
+    const ijkCoords = [];
+    const dimensions = segmentationVolume.dimensions;
+    let actualLen = 0;
+    for (let i = 0, len = scalarDataLength; i < len; i++) {
+        if (segVoxelManager.getAtIndex(i) !== 0) {
+            ijkCoords.push([
+                i % dimensions[0],
+                Math.floor((i / dimensions[0]) % dimensions[1]),
+                Math.floor(i / (dimensions[0] * dimensions[1])),
+            ]);
+            nonZeroVoxelIndices[actualLen++] = i;
+        }
     }
-    return value;
+    nonZeroVoxelIndices.length = actualLen;
+    const dynamicVolumeScalarDataArray = dynamicVolume.getScalarDataArrays();
+    const values = [];
+    const isSameVolume = dynamicVolumeScalarDataArray[0].length === scalarDataLength &&
+        JSON.stringify(dynamicVolume.spacing) ===
+            JSON.stringify(segmentationVolume.spacing);
+    if (isSameVolume) {
+        for (let i = 0; i < nonZeroVoxelIndices.length; i++) {
+            const indexValues = [];
+            frames.forEach((frame) => {
+                const activeScalarData = dynamicVolumeScalarDataArray[frame];
+                indexValues.push(activeScalarData[nonZeroVoxelIndices[i]]);
+            });
+            values.push(indexValues);
+        }
+        return [values, ijkCoords];
+    }
+    const callback = ({ pointLPS: segPointLPS, value: segValue, pointIJK: segPointIJK, }) => {
+        if (segValue === 0) {
+            return;
+        }
+        const overlapIJKMinMax = getVoxelOverlap(dynamicVolume.imageData, dynamicVolume.dimensions, dynamicVolume.spacing, segPointLPS);
+        let count = 0;
+        const perFrameSum = new Map();
+        frames.forEach((frame) => perFrameSum.set(frame, 0));
+        const averageCallback = ({ index }) => {
+            for (let i = 0; i < frames.length; i++) {
+                const value = dynamicVolumeScalarDataArray[i][index];
+                const frame = frames[i];
+                perFrameSum.set(frame, perFrameSum.get(frame) + value);
+            }
+            count++;
+        };
+        dynamicVolume.voxelManager.forEach(averageCallback, {
+            imageData: dynamicVolume.imageData,
+            boundsIJK: overlapIJKMinMax,
+        });
+        const averageValues = [];
+        perFrameSum.forEach((sum) => {
+            averageValues.push(sum / count);
+        });
+        ijkCoords.push(segPointIJK);
+        values.push(averageValues);
+    };
+    const { voxelManager } = maskImageData.get('voxelManager');
+    voxelManager.forEach(callback, {
+        imageData: maskImageData,
+    });
+    return [values, ijkCoords];
 }
 export default getDataInTime;
-//# sourceMappingURL=getDataInTime.js.map

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

@@ -1,4 +1,4 @@
 import getDataInTime from './getDataInTime';
-import generateImageFromTimeData from './generateImageFromTimeData';
+import { generateImageFromTimeData, updateVolumeFromTimeData } from './generateImageFromTimeData';
 export { getDataInTime };
-export { generateImageFromTimeData };
+export { generateImageFromTimeData, updateVolumeFromTimeData };

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

@@ -1,5 +1,4 @@
 import getDataInTime from './getDataInTime';
-import generateImageFromTimeData from './generateImageFromTimeData';
+import { generateImageFromTimeData, updateVolumeFromTimeData, } from './generateImageFromTimeData';
 export { getDataInTime };
-export { generateImageFromTimeData };
-//# sourceMappingURL=index.js.map
+export { generateImageFromTimeData, updateVolumeFromTimeData };

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { Annotation } from '../types';
+import type { Annotation } from '../types';
 declare function getAnnotationNearPoint(element: HTMLDivElement, canvasPoint: Types.Point2, proximity?: number): Annotation | null;
 declare function getAnnotationNearPointOnEnabledElement(enabledElement: Types.IEnabledElement, point: Types.Point2, proximity: number): Annotation | null;
 export { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement };

package/dist/esm/utilities/getAnnotationNearPoint.js

@@ -44,4 +44,3 @@ function findAnnotationNearPointByTool(tool, enabledElement, point, proximity) {
     return null;
 }
 export { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement };
-//# sourceMappingURL=getAnnotationNearPoint.js.map

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

@@ -1,6 +1,16 @@
-declare const getCalibratedLengthUnits: (handles: any, image: any) => string;
-declare const getCalibratedAreaUnits: (handles: any, image: any) => string;
-declare const getCalibratedScale: (image: any) => any;
+declare const getCalibratedLengthUnitsAndScale: (image: any, handles: any) => {
+    unit: string;
+    areaUnit: string;
+    scale: number;
+};
+declare const getCalibratedProbeUnitsAndValue: (image: any, handles: any) => {
+    units: string[];
+    values: any[];
+    calibrationType?: undefined;
+} | {
+    units: string[];
+    values: any[];
+    calibrationType: string;
+};
 declare const getCalibratedAspect: (image: any) => any;
-export default getCalibratedLengthUnits;
-export { getCalibratedAreaUnits, getCalibratedLengthUnits, getCalibratedScale, getCalibratedAspect, };
+export { getCalibratedLengthUnitsAndScale, getCalibratedAspect, getCalibratedProbeUnitsAndValue, };

package/dist/esm/utilities/getCalibratedUnits.js

@@ -1,34 +1,150 @@
-import { Enums } from '@cornerstonejs/core';
+import { Enums, utilities } from '@cornerstonejs/core';
 const { CalibrationTypes } = Enums;
 const PIXEL_UNITS = 'px';
-const getCalibratedLengthUnits = (handles, image) => {
+const SUPPORTED_REGION_DATA_TYPES = [
+    1,
+];
+const SUPPORTED_LENGTH_VARIANT = [
+    '3,3',
+];
+const SUPPORTED_PROBE_VARIANT = [
+    '4,3',
+];
+const UNIT_MAPPING = {
+    0: 'px',
+    1: 'percent',
+    2: 'dB',
+    3: 'cm',
+    4: 'seconds',
+    5: 'hertz',
+    6: 'dB/seconds',
+    7: 'cm/sec',
+    8: 'cm\xb2',
+    9: 'cm\xb2/s',
+    0xc: 'degrees',
+};
+const EPS = 1e-3;
+const SQUARE = '\xb2';
+const getCalibratedLengthUnitsAndScale = (image, handles) => {
     const { calibration, hasPixelSpacing } = image;
-    const units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-    if (!calibration || !calibration.type) {
-        return units;
+    let unit = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    let areaUnit = unit + SQUARE;
+    let scale = 1;
+    let calibrationType = '';
+    if (!calibration ||
+        (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
+        return { unit, areaUnit, scale };
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return PIXEL_UNITS;
+        return { unit: PIXEL_UNITS, areaUnit: PIXEL_UNITS + SQUARE, scale };
+    }
+    if (calibration.sequenceOfUltrasoundRegions) {
+        let imageIndex1, imageIndex2;
+        if (Array.isArray(handles) && handles.length === 2) {
+            [imageIndex1, imageIndex2] = handles;
+        }
+        else if (typeof handles === 'function') {
+            const points = handles();
+            imageIndex1 = points[0];
+            imageIndex2 = points[1];
+        }
+        let regions = calibration.sequenceOfUltrasoundRegions.filter((region) => imageIndex1[0] >= region.regionLocationMinX0 &&
+            imageIndex1[0] <= region.regionLocationMaxX1 &&
+            imageIndex1[1] >= region.regionLocationMinY0 &&
+            imageIndex1[1] <= region.regionLocationMaxY1 &&
+            imageIndex2[0] >= region.regionLocationMinX0 &&
+            imageIndex2[0] <= region.regionLocationMaxX1 &&
+            imageIndex2[1] >= region.regionLocationMinY0 &&
+            imageIndex2[1] <= region.regionLocationMaxY1);
+        if (!regions?.length) {
+            return { unit, areaUnit, scale };
+        }
+        regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
+            SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
+        if (!regions.length) {
+            return {
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
+                scale,
+            };
+        }
+        const region = regions[0];
+        const physicalDeltaX = Math.abs(region.physicalDeltaX);
+        const physicalDeltaY = Math.abs(region.physicalDeltaY);
+        const isSamePhysicalDelta = utilities.isEqual(physicalDeltaX, physicalDeltaY, EPS);
+        if (isSamePhysicalDelta) {
+            scale = 1 / physicalDeltaX;
+            calibrationType = 'US Region';
+            unit = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
+            areaUnit = unit + SQUARE;
+        }
+        else {
+            return {
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
+                scale,
+            };
+        }
     }
-    if (calibration.SequenceOfUltrasoundRegions) {
-        return 'US Region';
+    else if (calibration.scale) {
+        scale = calibration.scale;
     }
-    return `${units} ${calibration.type}`;
+    const types = [
+        CalibrationTypes.ERMF,
+        CalibrationTypes.USER,
+        CalibrationTypes.ERROR,
+        CalibrationTypes.PROJECTION,
+    ];
+    if (types.includes(calibration?.type)) {
+        calibrationType = calibration.type;
+    }
+    return {
+        unit: unit + (calibrationType ? ` ${calibrationType}` : ''),
+        areaUnit: areaUnit + (calibrationType ? ` ${calibrationType}` : ''),
+        scale,
+    };
 };
-const SQUARE = '\xb2';
-const getCalibratedAreaUnits = (handles, image) => {
-    const { calibration, hasPixelSpacing } = image;
-    const units = (hasPixelSpacing ? 'mm' : PIXEL_UNITS) + SQUARE;
-    if (!calibration || !calibration.type) {
-        return units;
+const getCalibratedProbeUnitsAndValue = (image, handles) => {
+    const [imageIndex] = handles;
+    const { calibration } = image;
+    let units = ['raw'];
+    let values = [null];
+    let calibrationType = '';
+    if (!calibration ||
+        (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
+        return { units, values };
     }
-    if (calibration.SequenceOfUltrasoundRegions) {
-        return 'US Region';
+    if (calibration.sequenceOfUltrasoundRegions) {
+        const supportedRegionsMetadata = calibration.sequenceOfUltrasoundRegions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
+            SUPPORTED_PROBE_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
+        if (!supportedRegionsMetadata?.length) {
+            return { units, values };
+        }
+        const region = supportedRegionsMetadata.find((region) => imageIndex[0] >= region.regionLocationMinX0 &&
+            imageIndex[0] <= region.regionLocationMaxX1 &&
+            imageIndex[1] >= region.regionLocationMinY0 &&
+            imageIndex[1] <= region.regionLocationMaxY1);
+        if (!region) {
+            return { units, values };
+        }
+        const { referencePixelX0 = 0, referencePixelY0 = 0 } = region;
+        const { physicalDeltaX, physicalDeltaY } = region;
+        const yValue = (imageIndex[1] - region.regionLocationMinY0 - referencePixelY0) *
+            physicalDeltaY;
+        const xValue = (imageIndex[0] - region.regionLocationMinX0 - referencePixelX0) *
+            physicalDeltaX;
+        calibrationType = 'US Region';
+        values = [xValue, yValue];
+        units = [
+            UNIT_MAPPING[region.physicalUnitsXDirection],
+            UNIT_MAPPING[region.physicalUnitsYDirection],
+        ];
     }
-    return `${units} ${calibration.type}`;
+    return {
+        units,
+        values,
+        calibrationType,
+    };
 };
-const getCalibratedScale = (image) => image.calibration?.scale || 1;
 const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
-export default getCalibratedLengthUnits;
-export { getCalibratedAreaUnits, getCalibratedLengthUnits, getCalibratedScale, getCalibratedAspect, };
-//# sourceMappingURL=getCalibratedUnits.js.map
+export { getCalibratedLengthUnitsAndScale, getCalibratedAspect, getCalibratedProbeUnitsAndValue, };

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

@@ -0,0 +1,7 @@
+type pixelUnitsOptions = {
+    isPreScaled: boolean;
+    isSuvScaled: boolean;
+};
+declare function getPixelValueUnits(modality: string, imageId: string, options: pixelUnitsOptions): string;
+export type { pixelUnitsOptions };
+export { getPixelValueUnits };

package/dist/esm/utilities/getPixelValueUnits.js

@@ -0,0 +1,27 @@
+import { metaData } from '@cornerstonejs/core';
+function getPixelValueUnits(modality, imageId, options) {
+    if (modality === 'CT') {
+        return 'HU';
+    }
+    else if (modality === 'PT') {
+        return _handlePTModality(imageId, options);
+    }
+    else {
+        return '';
+    }
+}
+function _handlePTModality(imageId, options) {
+    if (!options.isPreScaled) {
+        return 'raw';
+    }
+    if (options.isSuvScaled) {
+        return 'SUV';
+    }
+    const generalSeriesModule = metaData.get('generalSeriesModule', imageId);
+    if (generalSeriesModule?.modality === 'PT') {
+        const petSeriesModule = metaData.get('petSeriesModule', imageId);
+        return petSeriesModule?.units || 'unitless';
+    }
+    return 'unknown';
+}
+export { getPixelValueUnits };

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

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { BoundsIJK } from '../types';
+declare function getSphereBoundsInfo(circlePoints: [Types.Point3, Types.Point3], imageData: vtkImageData, viewport: any): {
+    boundsIJK: BoundsIJK;
+    centerWorld: Types.Point3;
+    radiusWorld: number;
+    topLeftWorld: Types.Point3;
+    bottomRightWorld: Types.Point3;
+};
+export { getSphereBoundsInfo };

package/dist/esm/utilities/getSphereBoundsInfo.js

@@ -0,0 +1,41 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { getBoundingBoxAroundShapeIJK } from './boundingBox';
+const { transformWorldToIndex } = csUtils;
+function getSphereBoundsInfo(circlePoints, imageData, viewport) {
+    const [bottom, top] = circlePoints;
+    const centerWorld = vec3.fromValues((bottom[0] + top[0]) / 2, (bottom[1] + top[1]) / 2, (bottom[2] + top[2]) / 2);
+    const radiusWorld = vec3.distance(bottom, top) / 2;
+    if (!viewport) {
+        throw new Error('viewport is required in order to calculate the sphere bounds');
+    }
+    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld);
+    return {
+        boundsIJK,
+        centerWorld: centerWorld,
+        radiusWorld,
+        topLeftWorld: topLeftWorld,
+        bottomRightWorld: bottomRightWorld,
+    };
+}
+function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
+    const [bottom, top] = circlePoints;
+    const dimensions = imageData.getDimensions();
+    const camera = viewport.getCamera();
+    const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
+    const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
+    const viewRight = vec3.create();
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const topLeftWorld = vec3.create();
+    const bottomRightWorld = vec3.create();
+    vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+    const topLeftIJK = transformWorldToIndex(imageData, topLeftWorld);
+    const bottomRightIJK = transformWorldToIndex(imageData, bottomRightWorld);
+    const pointsIJK = circlePoints.map((p) => transformWorldToIndex(imageData, p));
+    const boundsIJK = getBoundingBoxAroundShapeIJK([topLeftIJK, bottomRightIJK, ...pointsIJK], dimensions);
+    return { boundsIJK, topLeftWorld, bottomRightWorld };
+}
+export { getSphereBoundsInfo };

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

@@ -1,4 +1,4 @@
-import { ToolModes } from '../enums';
-declare type ModesFilter = Array<ToolModes>;
+import type { ToolModes } from '../enums';
+type ModesFilter = Array<ToolModes>;
 export default function getToolsWithModesForElement(element: HTMLDivElement, modesFilter: ModesFilter): any[];
 export {};

package/dist/esm/utilities/getToolsWithModesForElement.js

@@ -1,9 +1,9 @@
-import { ToolGroupManager } from '../store';
 import { getEnabledElement } from '@cornerstonejs/core';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
 export default function getToolsWithModesForElement(element, modesFilter) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngineId, viewportId } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return [];
     }
@@ -22,4 +22,3 @@ export default function getToolsWithModesForElement(element, modesFilter) {
     }
     return enabledTools;
 }
-//# sourceMappingURL=getToolsWithModesForElement.js.map

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+declare function getVOIMultipliers(viewport: Types.IStackViewport | Types.IVolumeViewport, volumeId?: string, options?: {
+    fixedPTWindowWidth?: boolean;
+}): [number, number];
+export { getVOIMultipliers as default, getVOIMultipliers };

package/dist/esm/utilities/getVOIMultipliers.js

@@ -0,0 +1,18 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { isViewportPreScaled } from './viewport';
+const DEFAULT_MULTIPLIER = 4;
+function getVOIMultipliers(viewport, volumeId, options) {
+    const modality = csUtils.getViewportModality(viewport, volumeId);
+    if (modality === 'PT') {
+        const { clientWidth, clientHeight } = viewport.element;
+        const ptMultiplier = 5 / Math.max(clientWidth, clientHeight);
+        const isPreScaled = isViewportPreScaled(viewport, volumeId);
+        const { fixedPTWindowWidth = true } = options ?? {};
+        const xMultiplier = fixedPTWindowWidth ? 0 : ptMultiplier;
+        return isPreScaled
+            ? [xMultiplier, ptMultiplier]
+            : [xMultiplier, DEFAULT_MULTIPLIER];
+    }
+    return [DEFAULT_MULTIPLIER, DEFAULT_MULTIPLIER];
+}
+export { getVOIMultipliers as default, getVOIMultipliers };

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

@@ -0,0 +1,3 @@
+import type { Annotation } from '../types';
+import type { Types } from '@cornerstonejs/core';
+export default function getViewportForAnnotation(annotation: Annotation): Types.IStackViewport | Types.IVolumeViewport | undefined;

package/dist/esm/utilities/getViewportForAnnotation.js

@@ -0,0 +1,5 @@
+import getViewportsForAnnotation from './getViewportsForAnnotation';
+export default function getViewportForAnnotation(annotation) {
+    const viewports = getViewportsForAnnotation(annotation);
+    return viewports.length ? viewports[0] : undefined;
+}

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../types';
+export default function getViewportsForAnnotation(annotation: Annotation): (Types.IStackViewport | Types.IVolumeViewport)[];

package/dist/esm/utilities/getViewportsForAnnotation.js

@@ -0,0 +1,16 @@
+import { getEnabledElements, utilities as csUtils } from '@cornerstonejs/core';
+const { isEqual } = csUtils;
+export default function getViewportsForAnnotation(annotation) {
+    const { metadata } = annotation;
+    return getEnabledElements()
+        .filter((enabledElement) => {
+        if (enabledElement.FrameOfReferenceUID === metadata.FrameOfReferenceUID) {
+            const viewport = enabledElement.viewport;
+            const { viewPlaneNormal, viewUp } = viewport.getCamera();
+            return (isEqual(viewPlaneNormal, metadata.viewPlaneNormal) &&
+                (!metadata.viewUp || isEqual(viewUp, metadata.viewUp)));
+        }
+        return;
+    })
+        .map((enabledElement) => enabledElement.viewport);
+}