@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/utilities/math/polyline/getSubPixelSpacingAndXYDirections.js

@@ -0,0 +1,72 @@
+import { StackViewport } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+const EPSILON = 1e-3;
+const getSubPixelSpacingAndXYDirections = (viewport, subPixelResolution) => {
+    let spacing;
+    let xDir;
+    let yDir;
+    if (viewport instanceof StackViewport) {
+        const imageData = viewport.getImageData();
+        if (!imageData) {
+            return;
+        }
+        xDir = imageData.direction.slice(0, 3);
+        yDir = imageData.direction.slice(3, 6);
+        spacing = imageData.spacing;
+    }
+    else {
+        const imageData = viewport.getImageData();
+        const { direction, spacing: volumeSpacing } = imageData;
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const iVector = direction.slice(0, 3);
+        const jVector = direction.slice(3, 6);
+        const kVector = direction.slice(6, 9);
+        const viewRight = vec3.create();
+        vec3.cross(viewRight, viewUp, viewPlaneNormal);
+        const absViewRightDotI = Math.abs(vec3.dot(viewRight, iVector));
+        const absViewRightDotJ = Math.abs(vec3.dot(viewRight, jVector));
+        const absViewRightDotK = Math.abs(vec3.dot(viewRight, kVector));
+        let xSpacing;
+        if (Math.abs(1 - absViewRightDotI) < EPSILON) {
+            xSpacing = volumeSpacing[0];
+            xDir = iVector;
+        }
+        else if (Math.abs(1 - absViewRightDotJ) < EPSILON) {
+            xSpacing = volumeSpacing[1];
+            xDir = jVector;
+        }
+        else if (Math.abs(1 - absViewRightDotK) < EPSILON) {
+            xSpacing = volumeSpacing[2];
+            xDir = kVector;
+        }
+        else {
+            throw new Error('No support yet for oblique plane planar contours');
+        }
+        const absViewUpDotI = Math.abs(vec3.dot(viewUp, iVector));
+        const absViewUpDotJ = Math.abs(vec3.dot(viewUp, jVector));
+        const absViewUpDotK = Math.abs(vec3.dot(viewUp, kVector));
+        let ySpacing;
+        if (Math.abs(1 - absViewUpDotI) < EPSILON) {
+            ySpacing = volumeSpacing[0];
+            yDir = iVector;
+        }
+        else if (Math.abs(1 - absViewUpDotJ) < EPSILON) {
+            ySpacing = volumeSpacing[1];
+            yDir = jVector;
+        }
+        else if (Math.abs(1 - absViewUpDotK) < EPSILON) {
+            ySpacing = volumeSpacing[2];
+            yDir = kVector;
+        }
+        else {
+            throw new Error('No support yet for oblique plane planar contours');
+        }
+        spacing = [xSpacing, ySpacing];
+    }
+    const subPixelSpacing = [
+        spacing[0] / subPixelResolution,
+        spacing[1] / subPixelResolution,
+    ];
+    return { spacing: subPixelSpacing, xDir, yDir };
+};
+export default getSubPixelSpacingAndXYDirections;

package/dist/esm/utilities/math/polyline/getWindingDirection.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getWindingDirection(polyline: Types.Point2[]): number;

package/dist/esm/utilities/math/polyline/getWindingDirection.js

@@ -0,0 +1,5 @@
+import getSignedArea from './getSignedArea';
+export default function getWindingDirection(polyline) {
+    const signedArea = getSignedArea(polyline);
+    return signedArea >= 0 ? 1 : -1;
+}

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

@@ -0,0 +1,23 @@
+import isClosed from './isClosed';
+import containsPoint from './containsPoint';
+import containsPoints from './containsPoints';
+import getAABB from './getAABB';
+import getArea from './getArea';
+import getSignedArea from './getSignedArea';
+import getWindingDirection from './getWindingDirection';
+import getNormal3 from './getNormal3';
+import getNormal2 from './getNormal2';
+import { mergePolylines, subtractPolylines } from './combinePolyline';
+import intersectPolyline from './intersectPolyline';
+import decimate from './decimate';
+import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import getLineSegmentIntersectionsCoordinates from './getLineSegmentIntersectionsCoordinates';
+import getClosestLineSegmentIntersection from './getClosestLineSegmentIntersection';
+import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirections';
+import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
+import addCanvasPointsToArray from './addCanvasPointsToArray';
+import pointCanProjectOnLine from './pointCanProjectOnLine';
+import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
+import { projectTo2D } from './projectTo2D';
+export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, isPointInsidePolyline3D, projectTo2D, };

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

@@ -0,0 +1,23 @@
+import isClosed from './isClosed';
+import containsPoint from './containsPoint';
+import containsPoints from './containsPoints';
+import getAABB from './getAABB';
+import getArea from './getArea';
+import getSignedArea from './getSignedArea';
+import getWindingDirection from './getWindingDirection';
+import getNormal3 from './getNormal3';
+import getNormal2 from './getNormal2';
+import { mergePolylines, subtractPolylines } from './combinePolyline';
+import intersectPolyline from './intersectPolyline';
+import decimate from './decimate';
+import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import getLineSegmentIntersectionsCoordinates from './getLineSegmentIntersectionsCoordinates';
+import getClosestLineSegmentIntersection from './getClosestLineSegmentIntersection';
+import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirections';
+import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
+import addCanvasPointsToArray from './addCanvasPointsToArray';
+import pointCanProjectOnLine from './pointCanProjectOnLine';
+import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
+import { projectTo2D } from './projectTo2D';
+export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, isPointInsidePolyline3D, projectTo2D, };

package/dist/esm/utilities/math/polyline/intersectPolyline.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function intersectPolyline(sourcePolyline: Types.Point2[], targetPolyline: Types.Point2[]): boolean;

package/dist/esm/utilities/math/polyline/intersectPolyline.js

@@ -0,0 +1,13 @@
+import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
+export default function intersectPolyline(sourcePolyline, targetPolyline) {
+    for (let i = 0, sourceLen = sourcePolyline.length; i < sourceLen; i++) {
+        const sourceP1 = sourcePolyline[i];
+        const sourceP2Index = i === sourceLen - 1 ? 0 : i + 1;
+        const sourceP2 = sourcePolyline[sourceP2Index];
+        const intersectionPointIndexes = getFirstLineSegmentIntersectionIndexes(targetPolyline, sourceP1, sourceP2);
+        if (intersectionPointIndexes?.length === 2) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/esm/utilities/math/polyline/isClosed.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function isClosed(polyline: Types.Point2[]): boolean;

package/dist/esm/utilities/math/polyline/isClosed.js

@@ -0,0 +1,12 @@
+import { glMatrix } from 'gl-matrix';
+import { distanceToPointSquared } from '../point';
+export default function isClosed(polyline) {
+    if (polyline.length < 3) {
+        return false;
+    }
+    const numPolylinePoints = polyline.length;
+    const firstPoint = polyline[0];
+    const lastPoint = polyline[numPolylinePoints - 1];
+    const distFirstToLastPoints = distanceToPointSquared(firstPoint, lastPoint);
+    return glMatrix.equals(0, distFirstToLastPoints);
+}

package/dist/esm/utilities/math/polyline/isPointInsidePolyline3D.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function isPointInsidePolyline3D(point: Types.Point3, polyline: Types.Point3[], options?: {
+    holes?: Types.Point3[][];
+}): boolean;

package/dist/esm/utilities/math/polyline/isPointInsidePolyline3D.js

@@ -0,0 +1,25 @@
+import containsPoint from './containsPoint';
+import { projectTo2D } from './projectTo2D';
+export function isPointInsidePolyline3D(point, polyline, options = {}) {
+    const { sharedDimensionIndex, projectedPolyline } = projectTo2D(polyline);
+    const { holes } = options;
+    const projectedHoles = [];
+    if (holes) {
+        for (let i = 0; i < holes.length; i++) {
+            const hole = holes[i];
+            const hole2D = [];
+            for (let j = 0; j < hole.length; j++) {
+                hole2D.push([
+                    hole[j][(sharedDimensionIndex + 1) % 3],
+                    hole[j][(sharedDimensionIndex + 2) % 3],
+                ]);
+            }
+            projectedHoles.push(hole2D);
+        }
+    }
+    const point2D = [
+        point[(sharedDimensionIndex + 1) % 3],
+        point[(sharedDimensionIndex + 2) % 3],
+    ];
+    return containsPoint(projectedPolyline, point2D, { holes: projectedHoles });
+}

package/dist/esm/utilities/math/polyline/planarFreehandROIInternalTypes.d.ts

@@ -0,0 +1,25 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+type PlanarFreehandROIDrawData = {
+    polylineIndex: number;
+    canvasPoints: Types.Point2[];
+    contourHoleProcessingEnabled: boolean;
+};
+type PlanarFreehandROIEditData = {
+    prevCanvasPoints: Types.Point2[];
+    editCanvasPoints: Types.Point2[];
+    fusedCanvasPoints: Types.Point2[];
+    startCrossingIndex?: Types.Point2;
+    editIndex: number;
+    snapIndex?: number;
+    newAnnotation?: boolean;
+};
+type PlanarFreehandROICommonData = {
+    annotation: PlanarFreehandROIAnnotation;
+    viewportIdsToRender: string[];
+    spacing: Types.Point2;
+    xDir: Types.Point3;
+    yDir: Types.Point3;
+    movingTextBox?: boolean;
+};
+export type { PlanarFreehandROIDrawData, PlanarFreehandROIEditData, PlanarFreehandROICommonData, };

package/dist/esm/utilities/math/polyline/pointCanProjectOnLine.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare const pointCanProjectOnLine: (p: Types.Point2, p1: Types.Point2, p2: Types.Point2, proximity: number) => boolean;
+export default pointCanProjectOnLine;

package/dist/esm/utilities/math/polyline/pointCanProjectOnLine.js

@@ -0,0 +1,32 @@
+import { vec2 } from 'gl-matrix';
+const pointCanProjectOnLine = (p, p1, p2, proximity) => {
+    const p1p = [p[0] - p1[0], p[1] - p1[1]];
+    const p1p2 = [p2[0] - p1[0], p2[1] - p1[1]];
+    const dot = p1p[0] * p1p2[0] + p1p[1] * p1p2[1];
+    if (dot < 0) {
+        return false;
+    }
+    const p1p2Mag = Math.sqrt(p1p2[0] * p1p2[0] + p1p2[1] * p1p2[1]);
+    if (p1p2Mag === 0) {
+        return false;
+    }
+    const projectionVectorMag = dot / p1p2Mag;
+    const p1p2UnitVector = [p1p2[0] / p1p2Mag, p1p2[1] / p1p2Mag];
+    const projectionVector = [
+        p1p2UnitVector[0] * projectionVectorMag,
+        p1p2UnitVector[1] * projectionVectorMag,
+    ];
+    const projectionPoint = [
+        p1[0] + projectionVector[0],
+        p1[1] + projectionVector[1],
+    ];
+    const distance = vec2.distance(p, projectionPoint);
+    if (distance > proximity) {
+        return false;
+    }
+    if (vec2.distance(p1, projectionPoint) > vec2.distance(p1, p2)) {
+        return false;
+    }
+    return true;
+};
+export default pointCanProjectOnLine;

package/dist/esm/utilities/math/polyline/pointsAreWithinCloseContourProximity.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare const pointsAreWithinCloseContourProximity: (p1: Types.Point2, p2: Types.Point2, closeContourProximity: number) => boolean;
+export default pointsAreWithinCloseContourProximity;

package/dist/esm/utilities/math/polyline/pointsAreWithinCloseContourProximity.js

@@ -0,0 +1,5 @@
+import { vec2 } from 'gl-matrix';
+const pointsAreWithinCloseContourProximity = (p1, p2, closeContourProximity) => {
+    return vec2.dist(p1, p2) < closeContourProximity;
+};
+export default pointsAreWithinCloseContourProximity;

package/dist/esm/utilities/math/polyline/projectTo2D.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function projectTo2D(polyline: Types.Point3[]): {
+    sharedDimensionIndex: any;
+    projectedPolyline: Types.Point2[];
+};

package/dist/esm/utilities/math/polyline/projectTo2D.js

@@ -0,0 +1,25 @@
+import { utilities } from '@cornerstonejs/core';
+const epsilon = 1e-6;
+export function projectTo2D(polyline) {
+    let sharedDimensionIndex;
+    const testPoints = utilities.getRandomSampleFromArray(polyline, 50);
+    for (let i = 0; i < 3; i++) {
+        if (testPoints.every((point, index, array) => Math.abs(point[i] - array[0][i]) < epsilon)) {
+            sharedDimensionIndex = i;
+            break;
+        }
+    }
+    if (sharedDimensionIndex === undefined) {
+        throw new Error('Cannot find a shared dimension index for polyline, probably oblique plane');
+    }
+    const points2D = [];
+    const firstDim = (sharedDimensionIndex + 1) % 3;
+    const secondDim = (sharedDimensionIndex + 2) % 3;
+    for (let i = 0; i < polyline.length; i++) {
+        points2D.push([polyline[i][firstDim], polyline[i][secondDim]]);
+    }
+    return {
+        sharedDimensionIndex,
+        projectedPolyline: points2D,
+    };
+}

package/dist/esm/utilities/math/rectangle/distanceToPoint.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function distanceToPoint(rect: number[], point: Types.Point2): number;

package/dist/esm/utilities/math/rectangle/distanceToPoint.js

@@ -0,0 +1,34 @@
+import * as lineSegment from '../line';
+function rectToLineSegments(left, top, width, height) {
+    const topLineStart = [left, top];
+    const topLineEnd = [left + width, top];
+    const rightLineStart = [left + width, top];
+    const rightLineEnd = [left + width, top + height];
+    const bottomLineStart = [left + width, top + height];
+    const bottomLineEnd = [left, top + height];
+    const leftLineStart = [left, top + height];
+    const leftLineEnd = [left, top];
+    const lineSegments = {
+        top: [topLineStart, topLineEnd],
+        right: [rightLineStart, rightLineEnd],
+        bottom: [bottomLineStart, bottomLineEnd],
+        left: [leftLineStart, leftLineEnd],
+    };
+    return lineSegments;
+}
+export default function distanceToPoint(rect, point) {
+    if (rect.length !== 4 || point.length !== 2) {
+        throw Error('rectangle:[left, top, width, height] or point: [x,y] not defined correctly');
+    }
+    const [left, top, width, height] = rect;
+    let minDistance = 655535;
+    const lineSegments = rectToLineSegments(left, top, width, height);
+    Object.keys(lineSegments).forEach((segment) => {
+        const [lineStart, lineEnd] = lineSegments[segment];
+        const distance = lineSegment.distanceToPoint(lineStart, lineEnd, point);
+        if (distance < minDistance) {
+            minDistance = distance;
+        }
+    });
+    return minDistance;
+}

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

@@ -0,0 +1,2 @@
+import distanceToPoint from './distanceToPoint';
+export { distanceToPoint };

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

@@ -0,0 +1,2 @@
+import distanceToPoint from './distanceToPoint';
+export { distanceToPoint };

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

@@ -0,0 +1,2 @@
+import pointInSphere from './pointInSphere';
+export { pointInSphere };

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

@@ -0,0 +1,2 @@
+import pointInSphere from './pointInSphere';
+export { pointInSphere };

package/dist/esm/utilities/math/sphere/pointInSphere.d.ts

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+import type { vec3 } from 'gl-matrix';
+type Sphere = {
+    center: Types.Point3 | vec3;
+    radius: number;
+    radius2?: number;
+};
+export default function pointInSphere(sphere: Sphere, pointLPS: vec3): boolean;
+export {};

package/dist/esm/utilities/math/sphere/pointInSphere.js

@@ -0,0 +1,8 @@
+export default function pointInSphere(sphere, pointLPS) {
+    const { center, radius } = sphere;
+    const radius2 = sphere.radius2 || radius * radius;
+    return ((pointLPS[0] - center[0]) * (pointLPS[0] - center[0]) +
+        (pointLPS[1] - center[1]) * (pointLPS[1] - center[1]) +
+        (pointLPS[2] - center[2]) * (pointLPS[2] - center[2]) <=
+        radius2);
+}

package/dist/esm/utilities/math/vec2/findClosestPoint.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function findClosestPoint(sourcePoints: Array<Types.Point2>, targetPoint: Types.Point2): Types.Point2;

package/dist/esm/utilities/math/vec2/findClosestPoint.js

@@ -0,0 +1,17 @@
+export default function findClosestPoint(sourcePoints, targetPoint) {
+    let minPoint = [0, 0];
+    let minDistance = Number.MAX_SAFE_INTEGER;
+    sourcePoints.forEach(function (sourcePoint) {
+        const distance = _distanceBetween(targetPoint, sourcePoint);
+        if (distance < minDistance) {
+            minDistance = distance;
+            minPoint = [...sourcePoint];
+        }
+    });
+    return minPoint;
+}
+function _distanceBetween(p1, p2) {
+    const [x1, y1] = p1;
+    const [x2, y2] = p2;
+    return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+}

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

@@ -0,0 +1,3 @@
+import findClosestPoint from './findClosestPoint';
+import liangBarksyClip from './liangBarksyClip';
+export { findClosestPoint, liangBarksyClip };

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

@@ -0,0 +1,3 @@
+import findClosestPoint from './findClosestPoint';
+import liangBarksyClip from './liangBarksyClip';
+export { findClosestPoint, liangBarksyClip };

package/dist/esm/utilities/math/vec2/liangBarksyClip.d.ts

@@ -0,0 +1 @@
+export default function clip(a: any, b: any, box: any, da?: any, db?: any): 1 | 0;

package/dist/esm/utilities/math/vec2/liangBarksyClip.js

@@ -0,0 +1,68 @@
+const EPSILON = 1e-6;
+const INSIDE = 1;
+const OUTSIDE = 0;
+function clipT(num, denom, c) {
+    const [tE, tL] = c;
+    if (Math.abs(denom) < EPSILON) {
+        return num < 0;
+    }
+    const t = num / denom;
+    if (denom > 0) {
+        if (t > tL) {
+            return 0;
+        }
+        if (t > tE) {
+            c[0] = t;
+        }
+    }
+    else {
+        if (t < tE) {
+            return 0;
+        }
+        if (t < tL) {
+            c[1] = t;
+        }
+    }
+    return 1;
+}
+export default function clip(a, b, box, da, db) {
+    const [x1, y1] = a;
+    const [x2, y2] = b;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    if (da === undefined || db === undefined) {
+        da = a;
+        db = b;
+    }
+    else {
+        da[0] = a[0];
+        da[1] = a[1];
+        db[0] = b[0];
+        db[1] = b[1];
+    }
+    if (Math.abs(dx) < EPSILON &&
+        Math.abs(dy) < EPSILON &&
+        x1 >= box[0] &&
+        x1 <= box[2] &&
+        y1 >= box[1] &&
+        y1 <= box[3]) {
+        return INSIDE;
+    }
+    const c = [0, 1];
+    if (clipT(box[0] - x1, dx, c) &&
+        clipT(x1 - box[2], -dx, c) &&
+        clipT(box[1] - y1, dy, c) &&
+        clipT(y1 - box[3], -dy, c)) {
+        const [tE, tL] = c;
+        if (tL < 1) {
+            db[0] = x1 + tL * dx;
+            db[1] = y1 + tL * dy;
+        }
+        if (tE > 0) {
+            da[0] += tE * dx;
+            da[1] += tE * dy;
+        }
+        return INSIDE;
+    }
+    return OUTSIDE;
+}

package/dist/esm/utilities/math/vec3/interpolateVec3.d.ts

@@ -0,0 +1,2 @@
+declare const interpolateVec3: (a: any, b: any, t: any) => number[];
+export { interpolateVec3 as default, interpolateVec3 };

package/dist/esm/utilities/math/vec3/interpolateVec3.js

@@ -0,0 +1,8 @@
+const interpolateVec3 = (a, b, t) => {
+    return [
+        a[0] * (1 - t) + b[0] * t,
+        a[1] * (1 - t) + b[1] * t,
+        a[2] * (1 - t) + b[2] * t,
+    ];
+};
+export { interpolateVec3 as default, interpolateVec3 };

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

@@ -0,0 +1,19 @@
+import type { Types } from '@cornerstonejs/core';
+export default function normalizeViewportPlane(viewport: Types.IViewport, boundsIJK: Types.BoundsIJK): {
+    toIJK: any;
+    boundsIJKPrime: any;
+    fromIJK: any;
+    error: string;
+} | {
+    boundsIJKPrime: any;
+    toIJK: (ijkPrime: any) => any;
+    fromIJK: (ijk: any) => any;
+    type: string;
+    error?: undefined;
+} | {
+    boundsIJKPrime: any;
+    toIJK: ([j, k, i]: [any, any, any]) => any[];
+    fromIJK: ([i, j, k]: [any, any, any]) => any[];
+    type: string;
+    error?: undefined;
+};

package/dist/esm/utilities/normalizeViewportPlane.js

@@ -0,0 +1,35 @@
+import { BaseVolumeViewport, utilities } from '@cornerstonejs/core';
+const { isEqual } = utilities;
+const acquisitionMapping = {
+    toIJK: (ijkPrime) => ijkPrime,
+    fromIJK: (ijk) => ijk,
+    type: 'acquistion',
+};
+const jkMapping = {
+    toIJK: ([j, k, i]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [j, k, i],
+    type: 'jk',
+};
+const ikMapping = {
+    toIJK: ([i, k, j]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [i, k, j],
+    type: 'ik',
+};
+export default function normalizeViewportPlane(viewport, boundsIJK) {
+    if (!(viewport instanceof BaseVolumeViewport)) {
+        return { ...acquisitionMapping, boundsIJKPrime: boundsIJK };
+    }
+    const { viewPlaneNormal } = viewport.getCamera();
+    const mapping = (isEqual(Math.abs(viewPlaneNormal[0]), 1) && jkMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[1]), 1) && ikMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[2]), 1) && acquisitionMapping);
+    if (!mapping) {
+        return {
+            toIJK: null,
+            boundsIJKPrime: null,
+            fromIJK: null,
+            error: `Only mappings orthogonal to acquisition plane are permitted, but requested ${viewPlaneNormal}`,
+        };
+    }
+    return { ...mapping, boundsIJKPrime: mapping.fromIJK(boundsIJK) };
+}

package/dist/esm/utilities/orientation/getOrientationStringLPS.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getOrientationStringLPS(vector: Types.Point3): string;

package/dist/esm/utilities/orientation/getOrientationStringLPS.js

@@ -0,0 +1,41 @@
+export default function getOrientationStringLPS(vector) {
+    let orientation = '';
+    const orientationX = vector[0] < 0 ? 'R' : 'L';
+    const orientationY = vector[1] < 0 ? 'A' : 'P';
+    const orientationZ = vector[2] < 0 ? 'F' : 'H';
+    const abs = [Math.abs(vector[0]), Math.abs(vector[1]), Math.abs(vector[2])];
+    const MIN = 0.0001;
+    for (let i = 0; i < 3; i++) {
+        if (abs[0] > MIN && abs[0] > abs[1] && abs[0] > abs[2]) {
+            orientation += orientationX;
+            abs[0] = 0;
+        }
+        else if (abs[1] > MIN && abs[1] > abs[0] && abs[1] > abs[2]) {
+            orientation += orientationY;
+            abs[1] = 0;
+        }
+        else if (abs[2] > MIN && abs[2] > abs[0] && abs[2] > abs[1]) {
+            orientation += orientationZ;
+            abs[2] = 0;
+        }
+        else if (abs[0] > MIN && abs[1] > MIN && abs[0] === abs[1]) {
+            orientation += orientationX + orientationY;
+            abs[0] = 0;
+            abs[1] = 0;
+        }
+        else if (abs[0] > MIN && abs[2] > MIN && abs[0] === abs[2]) {
+            orientation += orientationX + orientationZ;
+            abs[0] = 0;
+            abs[2] = 0;
+        }
+        else if (abs[1] > MIN && abs[2] > MIN && abs[1] === abs[2]) {
+            orientation += orientationY + orientationZ;
+            abs[1] = 0;
+            abs[2] = 0;
+        }
+        else {
+            break;
+        }
+    }
+    return orientation;
+}

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

@@ -0,0 +1,3 @@
+import getOrientationStringLPS from './getOrientationStringLPS';
+import invertOrientationStringLPS from './invertOrientationStringLPS';
+export { getOrientationStringLPS, invertOrientationStringLPS };

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

@@ -0,0 +1,3 @@
+import getOrientationStringLPS from './getOrientationStringLPS';
+import invertOrientationStringLPS from './invertOrientationStringLPS';
+export { getOrientationStringLPS, invertOrientationStringLPS };

package/dist/esm/utilities/orientation/invertOrientationStringLPS.d.ts

@@ -0,0 +1 @@
+export default function invertOrientationStringLPS(orientationString: string): string;

package/dist/esm/utilities/orientation/invertOrientationStringLPS.js

@@ -0,0 +1,10 @@
+export default function invertOrientationStringLPS(orientationString) {
+    let inverted = orientationString.replace('H', 'f');
+    inverted = inverted.replace('F', 'h');
+    inverted = inverted.replace('R', 'l');
+    inverted = inverted.replace('L', 'r');
+    inverted = inverted.replace('A', 'p');
+    inverted = inverted.replace('P', 'a');
+    inverted = inverted.toUpperCase();
+    return inverted;
+}

package/dist/esm/utilities/planar/filterAnnotationsForDisplay.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotations } from '../../types';
+export default function filterAnnotationsForDisplay(viewport: Types.IViewport, annotations: Annotations, filterOptions?: Types.ReferenceCompatibleOptions): Annotations;