@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,8 @@
+interface RotationMatrixInformation {
+    isStandard: boolean;
+    rotationMatrix: number[];
+}
+export declare function inverse3x3Matrix(matrix: number[]): number[];
+export declare function checkStandardBasis(directions: number[]): RotationMatrixInformation;
+export declare function rotatePoints(rotationMatrix: number[], origin: number[], points: number[]): number[];
+export {};

package/dist/esm/utilities/geometricSurfaceUtils.js

@@ -0,0 +1,103 @@
+function validate3x3Matrix(matrix) {
+    if (!Array.isArray(matrix) || matrix.length !== 9) {
+        throw new Error('Matrix must be an array of 9 numbers');
+    }
+    if (!matrix.every((n) => typeof n === 'number' && !isNaN(n))) {
+        throw new Error('Matrix must contain only valid numbers');
+    }
+}
+export function inverse3x3Matrix(matrix) {
+    validate3x3Matrix(matrix);
+    const mat = [
+        [matrix[0], matrix[1], matrix[2]],
+        [matrix[3], matrix[4], matrix[5]],
+        [matrix[6], matrix[7], matrix[8]],
+    ];
+    const determinant = mat[0][0] * (mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1]) -
+        mat[0][1] * (mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]) +
+        mat[0][2] * (mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]);
+    if (Math.abs(determinant) < 1e-10) {
+        throw new Error('Matrix is not invertible (determinant is zero)');
+    }
+    const adjugate = [
+        [
+            mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1],
+            -(mat[0][1] * mat[2][2] - mat[0][2] * mat[2][1]),
+            mat[0][1] * mat[1][2] - mat[0][2] * mat[1][1],
+        ],
+        [
+            -(mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]),
+            mat[0][0] * mat[2][2] - mat[0][2] * mat[2][0],
+            -(mat[0][0] * mat[1][2] - mat[0][2] * mat[1][0]),
+        ],
+        [
+            mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0],
+            -(mat[0][0] * mat[2][1] - mat[0][1] * mat[2][0]),
+            mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0],
+        ],
+    ];
+    const inverse = [];
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            inverse.push(adjugate[i][j] / determinant);
+        }
+    }
+    return inverse;
+}
+function normalizeVector(v) {
+    const magnitude = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    return v.map((component) => component / magnitude);
+}
+export function checkStandardBasis(directions) {
+    validate3x3Matrix(directions);
+    const xVector = directions.slice(0, 3);
+    const yVector = directions.slice(3, 6);
+    const zVector = directions.slice(6, 9);
+    const normalizedX = normalizeVector(xVector);
+    const normalizedY = normalizeVector(yVector);
+    const normalizedZ = normalizeVector(zVector);
+    const standardBasis = {
+        x: [1, 0, 0],
+        y: [0, 1, 0],
+        z: [0, 0, 1],
+    };
+    const epsilon = 1e-10;
+    const isStandard = normalizedX.every((val, i) => Math.abs(val - standardBasis.x[i]) < epsilon) &&
+        normalizedY.every((val, i) => Math.abs(val - standardBasis.y[i]) < epsilon) &&
+        normalizedZ.every((val, i) => Math.abs(val - standardBasis.z[i]) < epsilon);
+    const rotationMatrix = isStandard
+        ? [...standardBasis.x, ...standardBasis.y, ...standardBasis.z]
+        : inverse3x3Matrix([...normalizedX, ...normalizedY, ...normalizedZ]);
+    return {
+        isStandard,
+        rotationMatrix,
+    };
+}
+function rotatePoint(point, origin, rotationMatrix) {
+    const x = point[0] - origin[0];
+    const y = point[1] - origin[1];
+    const z = point[2] - origin[2];
+    return [
+        rotationMatrix[0] * x +
+            rotationMatrix[1] * y +
+            rotationMatrix[2] * z +
+            origin[0],
+        rotationMatrix[3] * x +
+            rotationMatrix[4] * y +
+            rotationMatrix[5] * z +
+            origin[1],
+        rotationMatrix[6] * x +
+            rotationMatrix[7] * y +
+            rotationMatrix[8] * z +
+            origin[2],
+    ];
+}
+export function rotatePoints(rotationMatrix, origin, points) {
+    const rotatedPoints = [];
+    for (let i = 0; i < points.length; i += 3) {
+        const point = points.slice(i, i + 3);
+        const rotated = rotatePoint(point, origin, rotationMatrix);
+        rotatedPoints.push(...rotated);
+    }
+    return rotatedPoints;
+}

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+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

@@ -0,0 +1,46 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { getAnnotations } from '../stateManagement/annotation/annotationState';
+import * as ToolGroupManager from '../store/ToolGroupManager';
+function getAnnotationNearPoint(element, canvasPoint, proximity = 5) {
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+        throw new Error('getAnnotationNearPoint: enabledElement not found');
+    }
+    return getAnnotationNearPointOnEnabledElement(enabledElement, canvasPoint, proximity);
+}
+function getAnnotationNearPointOnEnabledElement(enabledElement, point, proximity) {
+    const { renderingEngineId, viewportId } = enabledElement;
+    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return null;
+    }
+    const { _toolInstances: tools } = toolGroup;
+    for (const name in tools) {
+        const found = findAnnotationNearPointByTool(tools[name], enabledElement, point, proximity);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function findAnnotationNearPointByTool(tool, enabledElement, point, proximity) {
+    const { viewport } = enabledElement;
+    const annotations = getAnnotations(tool.constructor.toolName, viewport?.element);
+    const currentId = viewport?.getCurrentImageId?.();
+    if (annotations?.length) {
+        const { element } = enabledElement.viewport;
+        for (const annotation of annotations) {
+            const referencedImageId = annotation.metadata?.referencedImageId;
+            if ((currentId && referencedImageId && currentId !== referencedImageId) ||
+                !tool.isPointNearTool) {
+                continue;
+            }
+            if (tool.isPointNearTool(element, annotation, point, proximity, '') ||
+                tool.getHandleNearImagePoint(element, annotation, point, proximity)) {
+                return annotation;
+            }
+        }
+    }
+    return null;
+}
+export { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement };

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

@@ -0,0 +1,16 @@
+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 { getCalibratedLengthUnitsAndScale, getCalibratedAspect, getCalibratedProbeUnitsAndValue, };

package/dist/esm/utilities/getCalibratedUnits.js

@@ -0,0 +1,155 @@
+import { Enums, utilities } from '@cornerstonejs/core';
+const { CalibrationTypes } = Enums;
+const PIXEL_UNITS = 'px';
+const SUPPORTED_REGION_DATA_TYPES = [
+    1,
+    2,
+    3,
+    4,
+];
+const SUPPORTED_LENGTH_VARIANT = [
+    '3,3',
+    '4,7',
+];
+const SUPPORTED_PROBE_VARIANT = [
+    '4,3',
+    '4,7',
+];
+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;
+    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 { 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,
+            };
+        }
+    }
+    else if (calibration.scale) {
+        scale = calibration.scale;
+    }
+    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 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) {
+        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,
+        values,
+        calibrationType,
+    };
+};
+const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
+export { getCalibratedLengthUnitsAndScale, getCalibratedAspect, getCalibratedProbeUnitsAndValue, };

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

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

package/dist/esm/utilities/getPixelValueUnits.js

@@ -0,0 +1,31 @@
+import { metaData } from '@cornerstonejs/core';
+function getPixelValueUnitsImageId(imageId, options) {
+    const generalSeriesModule = metaData.get('generalSeriesModule', imageId);
+    return getPixelValueUnits(generalSeriesModule.modality, imageId, options);
+}
+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, getPixelValueUnitsImageId };

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

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

package/dist/esm/utilities/getSphereBoundsInfo.js

@@ -0,0 +1,64 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { getBoundingBoxAroundShapeIJK } from './boundingBox';
+const { transformWorldToIndex } = csUtils;
+function _getSphereBoundsInfo(circlePoints, imageData, directionVectors) {
+    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;
+    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld);
+    return {
+        boundsIJK,
+        centerWorld: centerWorld,
+        radiusWorld,
+        topLeftWorld: topLeftWorld,
+        bottomRightWorld: bottomRightWorld,
+    };
+}
+function getSphereBoundsInfo(circlePoints, imageData) {
+    const direction = imageData.getDirection();
+    const rowCosine = vec3.fromValues(direction[0], direction[1], direction[2]);
+    const columnCosine = vec3.fromValues(direction[3], direction[4], direction[5]);
+    const scanAxis = vec3.fromValues(direction[6], direction[7], direction[8]);
+    const viewPlaneNormal = vec3.negate(vec3.create(), scanAxis);
+    const directionVectors = {
+        row: rowCosine,
+        column: columnCosine,
+        normal: viewPlaneNormal,
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function getSphereBoundsInfoFromViewport(circlePoints, imageData, viewport) {
+    if (!viewport) {
+        throw new Error('viewport is required in order to calculate the sphere bounds');
+    }
+    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 directionVectors = {
+        row: viewRight,
+        normal: viewPlaneNormal,
+        column: vec3.negate(vec3.create(), viewUp),
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld) {
+    const dimensions = imageData.getDimensions();
+    const { row: rowCosine, column: columnCosine, normal: vecNormal, } = directionVectors;
+    const topLeftWorld = vec3.create();
+    const bottomRightWorld = vec3.create();
+    vec3.scaleAndAdd(topLeftWorld, centerWorld, vecNormal, radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, centerWorld, vecNormal, -radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, columnCosine, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, columnCosine, radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, rowCosine, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, rowCosine, 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, getSphereBoundsInfoFromViewport };

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,24 @@
+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 = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (!toolGroup) {
+        return [];
+    }
+    const enabledTools = [];
+    const toolGroupToolNames = Object.keys(toolGroup.toolOptions);
+    for (let j = 0; j < toolGroupToolNames.length; j++) {
+        const toolName = toolGroupToolNames[j];
+        const toolOptions = toolGroup.toolOptions[toolName];
+        if (!toolOptions) {
+            continue;
+        }
+        if (modesFilter.includes(toolOptions.mode)) {
+            const toolInstance = toolGroup.getToolInstance(toolName);
+            enabledTools.push(toolInstance);
+        }
+    }
+    return enabledTools;
+}

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

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

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

package/dist/esm/utilities/index.js

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

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

@@ -0,0 +1,2 @@
+export default isObject;
+declare function isObject(value: any): boolean;

package/dist/esm/utilities/isObject.js

@@ -0,0 +1,5 @@
+function isObject(value) {
+    const type = typeof value;
+    return value !== null && (type === 'object' || type === 'function');
+}
+export default isObject;