@cornerstonejs/tools 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/esm/utilities/contours/interpolation/selectHandles.js

@@ -0,0 +1,162 @@
+import { vec3 } from 'gl-matrix';
+import { utilities } from '@cornerstonejs/core';
+const { PointsManager } = utilities;
+export default function selectHandles(polyline, handleCount = 12) {
+    const handles = PointsManager.create3(handleCount);
+    handles.sources = [];
+    const { sources: destPoints } = handles;
+    const { length, sources: sourcePoints = [] } = polyline;
+    const distance = 5;
+    if (length < distance * 3) {
+        return polyline.subselect(handleCount);
+    }
+    const interval = Math.floor(Math.max((2 * length) / handleCount, distance * 2));
+    sourcePoints.forEach(() => destPoints.push(PointsManager.create3(handleCount)));
+    const dotValues = createDotValues(polyline, distance);
+    const minimumRegions = findMinimumRegions(dotValues, handleCount);
+    const indices = [];
+    if (minimumRegions?.length > 2) {
+        let lastHandle = -1;
+        const thirdInterval = interval / 3;
+        minimumRegions.forEach((region) => {
+            const [start, , end] = region;
+            const midIndex = Math.ceil((start + end) / 2);
+            if (end - lastHandle < thirdInterval) {
+                return;
+            }
+            if (midIndex - start > 2 * thirdInterval) {
+                addInterval(indices, lastHandle, start, interval, length);
+                lastHandle = addInterval(indices, start, midIndex, interval, length);
+            }
+            else {
+                lastHandle = addInterval(indices, lastHandle, midIndex, interval, length);
+            }
+            if (end - lastHandle > thirdInterval) {
+                lastHandle = addInterval(indices, lastHandle, end, interval, length);
+            }
+        });
+        const firstHandle = indices[0];
+        const lastDistance = indexValue(firstHandle + length - lastHandle, length);
+        if (lastDistance > 2 * thirdInterval) {
+            addInterval(indices, lastHandle, firstHandle - thirdInterval, interval, length);
+        }
+    }
+    else {
+        const interval = Math.floor(length / handleCount);
+        addInterval(indices, -1, length - interval, interval, length);
+    }
+    indices.forEach((index) => {
+        const point = polyline.getPointArray(index);
+        handles.push(point);
+        sourcePoints.forEach((source, destSourceIndex) => destPoints[destSourceIndex].push(source.getPoint(index)));
+    });
+    return handles;
+}
+export function createDotValues(polyline, distance = 6) {
+    const { length } = polyline;
+    const prevVec3 = vec3.create();
+    const nextVec3 = vec3.create();
+    const dotValues = new Float32Array(length);
+    for (let i = 0; i < length; i++) {
+        const point = polyline.getPoint(i);
+        const prevPoint = polyline.getPoint(i - distance);
+        const nextPoint = polyline.getPoint((i + distance) % length);
+        vec3.sub(prevVec3, point, prevPoint);
+        vec3.sub(nextVec3, nextPoint, point);
+        const dot = vec3.dot(prevVec3, nextVec3) / (vec3.len(prevVec3) * vec3.len(nextVec3));
+        dotValues[i] = dot;
+    }
+    return dotValues;
+}
+function findMinimumRegions(dotValues, handleCount) {
+    const { max, deviation } = getStats(dotValues);
+    const { length } = dotValues;
+    if (deviation < 0.01 || length < handleCount * 3) {
+        return [];
+    }
+    const inflection = [];
+    let pair = null;
+    let minValue;
+    let minIndex = 0;
+    for (let i = 0; i < length; i++) {
+        const dot = dotValues[i];
+        if (dot < max - deviation) {
+            if (pair) {
+                pair[2] = i;
+                if (dot < minValue) {
+                    minValue = dot;
+                    minIndex = i;
+                }
+                pair[1] = minIndex;
+            }
+            else {
+                minValue = dot;
+                minIndex = i;
+                pair = [i, i, i];
+            }
+        }
+        else {
+            if (pair) {
+                inflection.push(pair);
+                pair = null;
+            }
+        }
+    }
+    if (pair) {
+        if (inflection[0][0] === 0) {
+            inflection[0][0] = pair[0];
+        }
+        else {
+            pair[1] = minIndex;
+            pair[2] = length - 1;
+            inflection.push(pair);
+        }
+    }
+    return inflection;
+}
+export function addInterval(indices, start, finish, interval, length) {
+    if (finish < start) {
+        finish += length;
+    }
+    const distance = finish - start;
+    const count = Math.ceil(distance / interval);
+    if (count <= 0) {
+        if (indices[indices.length - 1] !== finish) {
+            indices.push(indexValue(finish, length));
+        }
+        return finish;
+    }
+    for (let i = 1; i <= count; i++) {
+        const index = indexValue(start + (i * distance) / count, length);
+        indices.push(index);
+    }
+    return indices[indices.length - 1];
+}
+function indexValue(v, length) {
+    return (Math.round(v) + length) % length;
+}
+function getStats(dotValues) {
+    const { length } = dotValues;
+    let sum = 0;
+    let min = Infinity;
+    let max = -Infinity;
+    let sumSq = 0;
+    for (let i = 0; i < length; i++) {
+        const dot = dotValues[i];
+        sum += dot;
+        min = Math.min(min, dot);
+        max = Math.max(max, dot);
+    }
+    const mean = sum / length;
+    for (let i = 0; i < length; i++) {
+        const valueDiff = dotValues[i] - mean;
+        sumSq += valueDiff * valueDiff;
+    }
+    return {
+        mean,
+        max,
+        min,
+        sumSq,
+        deviation: Math.sqrt(sumSq / length),
+    };
+}

package/dist/esm/utilities/contours/interpolation/updateChildInterpolationUID.d.ts

@@ -0,0 +1,2 @@
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+export default function updateChildInterpolationUID(annotation: InterpolationROIAnnotation): string;

package/dist/esm/utilities/contours/interpolation/updateChildInterpolationUID.js

@@ -0,0 +1,12 @@
+import * as annotationState from '../../../stateManagement/annotation';
+export default function updateChildInterpolationUID(annotation) {
+    const { parentAnnotationUID, annotationUID } = annotation;
+    if (!parentAnnotationUID) {
+        return annotation.interpolationUID;
+    }
+    const parentAnnotation = annotationState.state.getAnnotation(parentAnnotationUID);
+    const { interpolationUID } = parentAnnotation;
+    const index = parentAnnotation.childAnnotationUIDs.indexOf(annotationUID);
+    annotation.interpolationUID = `${interpolationUID}-${index}`;
+    return annotation.interpolationUID;
+}

package/dist/esm/utilities/contours/reverseIfAntiClockwise.d.ts

@@ -0,0 +1,2 @@
+import { Types } from '@cornerstonejs/core';
+export default function reverseIfAntiClockwise(points: Types.Point2[], ...otherListsToReverse: unknown[][]): Types.Point2[];

package/dist/esm/utilities/contours/reverseIfAntiClockwise.js

@@ -0,0 +1,11 @@
+import { getSignedArea } from '../math/polyline';
+export default function reverseIfAntiClockwise(points, ...otherListsToReverse) {
+    const signedArea = getSignedArea(points);
+    if (signedArea < 0) {
+        if (otherListsToReverse) {
+            otherListsToReverse.forEach((list) => list.reverse());
+        }
+        return points.slice().reverse();
+    }
+    return points;
+}

package/dist/esm/utilities/contours/updateContourPolyline.d.ts

@@ -0,0 +1,16 @@
+import { Types } from '@cornerstonejs/core';
+import type { ContourAnnotation } from '../../types';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
+export default function updateContourPolyline(annotation: ContourAnnotation, polylineData: {
+    points: Types.Point2[];
+    closed?: boolean;
+    targetWindingDirection?: ContourWindingDirection;
+}, transforms: {
+    canvasToWorld: (point: Types.Point2) => Types.Point3;
+    worldToCanvas: (point: Types.Point3) => Types.Point2;
+}, options?: {
+    decimate?: {
+        enabled?: boolean;
+        epsilon?: number;
+    };
+}): void;

package/dist/esm/utilities/contours/updateContourPolyline.js

@@ -0,0 +1,48 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import * as math from '../math';
+import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement';
+export default function updateContourPolyline(annotation, polylineData, transforms, options) {
+    const { canvasToWorld, worldToCanvas } = transforms;
+    const { data } = annotation;
+    const { targetWindingDirection } = polylineData;
+    let { points: polyline } = polylineData;
+    if (options?.decimate?.enabled) {
+        polyline = math.polyline.decimate(polylineData.points, options?.decimate?.epsilon);
+    }
+    let { closed } = polylineData;
+    const numPoints = polyline.length;
+    const polylineWorldPoints = new Array(numPoints);
+    const currentPolylineWindingDirection = math.polyline.getWindingDirection(polyline);
+    const parentAnnotation = getParentAnnotation(annotation);
+    if (closed === undefined) {
+        let currentClosedState = false;
+        if (polyline.length > 3) {
+            const lastToFirstDist = math.point.distanceToPointSquared(polyline[0], polyline[numPoints - 1]);
+            currentClosedState = csUtils.isEqual(0, lastToFirstDist);
+        }
+        closed = currentClosedState;
+    }
+    let windingDirection = parentAnnotation
+        ? parentAnnotation.data.contour.windingDirection * -1
+        : targetWindingDirection;
+    if (windingDirection === undefined) {
+        windingDirection = currentPolylineWindingDirection;
+    }
+    if (windingDirection !== currentPolylineWindingDirection) {
+        polyline.reverse();
+    }
+    const handlePoints = data.handles.points.map((p) => worldToCanvas(p));
+    if (handlePoints.length > 2) {
+        const currentHandlesWindingDirection = math.polyline.getWindingDirection(handlePoints);
+        if (currentHandlesWindingDirection !== windingDirection) {
+            data.handles.points.reverse();
+        }
+    }
+    for (let i = 0; i < numPoints; i++) {
+        polylineWorldPoints[i] = canvasToWorld(polyline[i]);
+    }
+    data.contour.polyline = polylineWorldPoints;
+    data.contour.closed = closed;
+    data.contour.windingDirection = windingDirection;
+    invalidateAnnotation(annotation);
+}

package/dist/esm/utilities/debounce.js

@@ -111,4 +111,3 @@ function debounce(func, wait, options) {
     return debounced;
 }
 export default debounce;
-//# sourceMappingURL=debounce.js.map

package/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.js

@@ -22,4 +22,3 @@ function _determineCorners(canvasPoints) {
         return a[1] < b[1] ? -1 : 1;
     }
 }
-//# sourceMappingURL=getTextBoxCoordsCanvas.js.map

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

@@ -1,3 +1,2 @@
 import getTextBoxCoordsCanvas from './getTextBoxCoordsCanvas';
 export { getTextBoxCoordsCanvas };
-//# sourceMappingURL=index.js.map

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

@@ -40,4 +40,3 @@ function generateImageFromTimeData(dynamicVolume, operation, frameNumbers) {
     }
 }
 export default generateImageFromTimeData;
-//# sourceMappingURL=generateImageFromTimeData.js.map

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

@@ -2,6 +2,6 @@ import { 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,24 @@
 import { utilities, cache } from '@cornerstonejs/core';
+import { getVoxelOverlap } from '../segmentation/utilities';
+import pointInShapeCallback from '../pointInShapeCallback';
 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 +43,67 @@ 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 segScalarData = segmentationVolume.getScalarData();
+    const len = segScalarData.length;
+    const nonZeroVoxelIndices = [];
+    nonZeroVoxelIndices.length = len;
+    const ijkCoords = [];
+    const dimensions = segmentationVolume.dimensions;
+    let actualLen = 0;
+    for (let i = 0, len = segScalarData.length; i < len; i++) {
+        if (segScalarData[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 === len &&
+        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++;
+        };
+        pointInShapeCallback(dynamicVolume.imageData, () => true, averageCallback, overlapIJKMinMax);
+        const averageValues = [];
+        perFrameSum.forEach((sum) => {
+            averageValues.push(sum / count);
+        });
+        ijkCoords.push(segPointIJK);
+        values.push(averageValues);
+    };
+    pointInShapeCallback(maskImageData, () => true, callback);
+    return [values, ijkCoords];
 }
 export default getDataInTime;
-//# sourceMappingURL=getDataInTime.js.map

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

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

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,22 @@
-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) => {
+    lengthUnits: string;
+    areaUnits: string;
+    scale: number;
+    units?: undefined;
+} | {
+    units: string;
+    areaUnits: string;
+    scale: number;
+    lengthUnits?: undefined;
+};
+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,141 @@
-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 = {
+    3: 'cm',
+    4: 'seconds',
+};
+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 lengthUnits = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    let areaUnits = lengthUnits + SQUARE;
+    let scale = 1;
+    let calibrationType = '';
+    if (!calibration ||
+        (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
+        return { lengthUnits, areaUnits, scale };
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return PIXEL_UNITS;
+        return { units: PIXEL_UNITS, areaUnits: 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 { lengthUnits, areaUnits, scale };
+        }
+        regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
+            SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
+        if (!regions.length) {
+            return {
+                lengthUnits: PIXEL_UNITS,
+                areaUnits: 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 * 10);
+            calibrationType = 'US Region';
+            lengthUnits = 'mm';
+            areaUnits = 'mm' + SQUARE;
+        }
+        else {
+            return {
+                lengthUnits: PIXEL_UNITS,
+                areaUnits: 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 {
+        lengthUnits: lengthUnits + (calibrationType ? ` ${calibrationType}` : ''),
+        areaUnits: areaUnits + (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,6 @@
+type pixelUnitsOptions = {
+    isPreScaled: boolean;
+    isSuvScaled: boolean;
+};
+declare function getPixelValueUnits(modality: string, imageId: string, options: pixelUnitsOptions): string;
+export { getPixelValueUnits, pixelUnitsOptions };

package/dist/esm/utilities/getPixelValueUnits.js

@@ -0,0 +1,26 @@
+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';
+    }
+}
+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 { 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 };