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

package/dist/esm/utilities/math/aabb/distanceToPointSquared.js

@@ -0,0 +1,20 @@
+export default function distanceToPointSquared(aabb, point) {
+    const aabbWidth = aabb.maxX - aabb.minX;
+    const aabbHeight = aabb.maxY - aabb.minY;
+    const aabbSize = [aabbWidth, aabbHeight];
+    const aabbCenter = [
+        aabb.minX + aabbWidth / 2,
+        aabb.minY + aabbHeight / 2,
+    ];
+    const translatedPoint = [
+        Math.abs(point[0] - aabbCenter[0]),
+        Math.abs(point[1] - aabbCenter[1]),
+    ];
+    const dx = translatedPoint[0] - aabbSize[0] * 0.5;
+    const dy = translatedPoint[1] - aabbSize[1] * 0.5;
+    if (dx > 0 && dy > 0) {
+        return dx * dx + dy * dy;
+    }
+    const dist = Math.max(dx, 0) + Math.max(dy, 0);
+    return dist * dist;
+}

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

@@ -0,0 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';

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

@@ -0,0 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';

package/dist/esm/utilities/math/aabb/intersectAABB.d.ts

@@ -0,0 +1,2 @@
+import { Types } from '@cornerstonejs/core';
+export default function intersectAABB(aabb1: Types.AABB2, aabb2: Types.AABB2): boolean;

package/dist/esm/utilities/math/aabb/intersectAABB.js

@@ -0,0 +1,6 @@
+export default function intersectAABB(aabb1, aabb2) {
+    return (aabb1.minX <= aabb2.maxX &&
+        aabb1.maxX >= aabb2.minX &&
+        aabb1.minY <= aabb2.maxY &&
+        aabb1.maxY >= aabb2.minY);
+}

package/dist/esm/utilities/math/angle/angleBetweenLines.d.ts

@@ -1,4 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-declare type Line = [Types.Point3, Types.Point3];
+type Line2D = [Types.Point2, Types.Point2];
+type Line3D = [Types.Point3, Types.Point3];
+type Line = Line2D | Line3D;
 export default function angleBetweenLines(line1: Line, line2: Line): number;
 export {};

package/dist/esm/utilities/math/angle/angleBetweenLines.js

@@ -1,5 +1,5 @@
-import { vec3 } from 'gl-matrix';
-export default function angleBetweenLines(line1, line2) {
+import { vec2, vec3 } from 'gl-matrix';
+function angleBetween3DLines(line1, line2) {
     const [p1, p2] = line1;
     const [p3, p4] = line2;
     const v1 = vec3.sub(vec3.create(), p2, p1);
@@ -11,4 +11,20 @@ export default function angleBetweenLines(line1, line2) {
     const radian = Math.acos(cos);
     return (radian * 180) / Math.PI;
 }
-//# sourceMappingURL=angleBetweenLines.js.map
+function angleBetween2DLines(line1, line2) {
+    const [p1, p2] = line1;
+    const [p3, p4] = line2;
+    const v1 = vec2.sub(vec2.create(), p2, p1);
+    const v2 = vec2.sub(vec2.create(), p3, p4);
+    const dot = vec2.dot(v1, v2);
+    const v1Length = vec2.length(v1);
+    const v2Length = vec2.length(v2);
+    const cos = dot / (v1Length * v2Length);
+    return Math.acos(cos) * (180 / Math.PI);
+}
+export default function angleBetweenLines(line1, line2) {
+    const is3D = line1[0].length === 3;
+    return is3D
+        ? angleBetween3DLines(line1, line2)
+        : angleBetween2DLines(line1, line2);
+}

package/dist/esm/utilities/math/basic/BasicStatsCalculator.d.ts

@@ -1,14 +1,21 @@
-import { Statistics } from '../../../types';
+import { NamedStatistics } from '../../../types';
 import Calculator from './Calculator';
 export default class BasicStatsCalculator extends Calculator {
     private static max;
-    private static currentMax;
+    private static min;
     private static sum;
-    private static sumSquares;
-    private static squaredDiffSum;
     private static count;
-    static statsCallback: ({ value: newValue }: {
+    private static runMean;
+    private static m2;
+    private static pointsInShape;
+    static statsInit(options: {
+        noPointsCollection: boolean;
+    }): void;
+    static statsCallback: ({ value: newValue, pointLPS }: {
         value: any;
+        pointLPS?: any;
     }) => void;
-    static getStatistics: () => Statistics[];
+    static getStatistics: (options?: {
+        unit: string;
+    }) => NamedStatistics;
 }

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

@@ -1,36 +1,92 @@
+import { utilities } from '@cornerstonejs/core';
 import Calculator from './Calculator';
+const { PointsManager } = utilities;
 export default class BasicStatsCalculator extends Calculator {
-    static { this.max = -Infinity; }
-    static { this.currentMax = 0; }
-    static { this.sum = 0; }
-    static { this.sumSquares = 0; }
-    static { this.squaredDiffSum = 0; }
+    static { this.max = [-Infinity]; }
+    static { this.min = [Infinity]; }
+    static { this.sum = [0]; }
     static { this.count = 0; }
-    static { this.statsCallback = ({ value: newValue }) => {
-        if (newValue > this.max) {
-            this.max = newValue;
-            this.currentMax = newValue;
+    static { this.runMean = [0]; }
+    static { this.m2 = [0]; }
+    static { this.pointsInShape = PointsManager.create3(1024); }
+    static statsInit(options) {
+        if (options.noPointsCollection) {
+            BasicStatsCalculator.pointsInShape = null;
         }
+    }
+    static { this.statsCallback = ({ value: newValue, pointLPS = null }) => {
+        if (Array.isArray(newValue) &&
+            newValue.length > 1 &&
+            this.max.length === 1) {
+            this.max.push(this.max[0], this.max[0]);
+            this.min.push(this.min[0], this.min[0]);
+            this.sum.push(this.sum[0], this.sum[0]);
+            this.runMean.push(0, 0);
+            this.m2.push(this.m2[0], this.m2[0]);
+        }
+        this.pointsInShape?.push(pointLPS);
+        const newArray = Array.isArray(newValue) ? newValue : [newValue];
         this.count += 1;
-        this.sum += newValue;
-        this.sumSquares += newValue ** 2;
-        this.squaredDiffSum += Math.pow(newValue - this.sum / this.count, 2);
+        this.max.map((it, idx) => {
+            const value = newArray[idx];
+            const delta = value - this.runMean[idx];
+            this.sum[idx] += value;
+            this.runMean[idx] += delta / this.count;
+            const delta2 = value - this.runMean[idx];
+            this.m2[idx] += delta * delta2;
+            this.min[idx] = Math.min(this.min[idx], value);
+            this.max[idx] = Math.max(it, value);
+        });
     }; }
-    static { this.getStatistics = () => {
-        const mean = this.sum / this.count;
-        const stdDev = Math.sqrt(this.squaredDiffSum / this.count);
-        const stdDevWithSumSquare = Math.sqrt(this.sumSquares / this.count - mean ** 2);
-        this.max = -Infinity;
-        this.sum = 0;
-        this.sumSquares = 0;
-        this.squaredDiffSum = 0;
+    static { this.getStatistics = (options) => {
+        const mean = this.sum.map((sum) => sum / this.count);
+        const stdDev = this.m2.map((squaredDiffSum) => Math.sqrt(squaredDiffSum / this.count));
+        const unit = options?.unit || null;
+        const named = {
+            max: {
+                name: 'max',
+                label: 'Max Pixel',
+                value: singleArrayAsNumber(this.max),
+                unit,
+            },
+            min: {
+                name: 'min',
+                label: 'Min Pixel',
+                value: singleArrayAsNumber(this.min),
+                unit,
+            },
+            mean: {
+                name: 'mean',
+                label: 'Mean Pixel',
+                value: singleArrayAsNumber(mean),
+                unit,
+            },
+            stdDev: {
+                name: 'stdDev',
+                label: 'Standard Deviation',
+                value: singleArrayAsNumber(stdDev),
+                unit,
+            },
+            count: {
+                name: 'count',
+                label: 'Pixel Count',
+                value: this.count,
+                unit: null,
+            },
+            pointsInShape: this.pointsInShape,
+            array: [],
+        };
+        named.array.push(named.max, named.mean, named.stdDev, named.stdDev, named.count);
+        this.max = [-Infinity];
+        this.min = [Infinity];
+        this.sum = [0];
+        this.m2 = [0];
+        this.runMean = [0];
         this.count = 0;
-        return [
-            { name: 'max', value: this.currentMax, unit: null },
-            { name: 'mean', value: mean, unit: null },
-            { name: 'stdDev', value: stdDev, unit: null },
-            { name: 'stdDevWithSumSquare', value: stdDevWithSumSquare, unit: null },
-        ];
+        this.pointsInShape = PointsManager.create3(1024);
+        return named;
     }; }
 }
-//# sourceMappingURL=BasicStatsCalculator.js.map
+function singleArrayAsNumber(val) {
+    return val.length === 1 ? val[0] : val;
+}

package/dist/esm/utilities/math/basic/Calculator.d.ts

@@ -1,8 +1,8 @@
-import { Statistics } from '../../../types';
+import { NamedStatistics } from '../../../types';
 declare abstract class Calculator {
     static run: ({ value }: {
         value: any;
     }) => void;
-    static getStatistics: () => Statistics[];
+    static getStatistics: () => NamedStatistics;
 }
 export default Calculator;

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

@@ -1,4 +1,3 @@
 class Calculator {
 }
 export default Calculator;
-//# sourceMappingURL=Calculator.js.map

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

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

package/dist/esm/utilities/math/circle/_types.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-export declare type canvasCoordinates = [
+export type canvasCoordinates = [
     Types.Point2,
     Types.Point2
 ];

package/dist/esm/utilities/math/circle/_types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=_types.js.map

package/dist/esm/utilities/math/circle/getCanvasCircleCorners.js

@@ -6,4 +6,3 @@ export default function getCanvasCircleCorners(circleCanvasPoints) {
     const bottomRight = [center[0] + radius, center[1] + radius];
     return [topLeft, bottomRight];
 }
-//# sourceMappingURL=getCanvasCircleCorners.js.map

package/dist/esm/utilities/math/circle/getCanvasCircleRadius.js

@@ -3,4 +3,3 @@ export default function getCanvasCircleRadius(circleCanvasPoints) {
     const [center, end] = circleCanvasPoints;
     return distanceToPoint(center, end);
 }
-//# sourceMappingURL=getCanvasCircleRadius.js.map

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

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

package/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.d.ts

@@ -1,9 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
-declare type canvasCoordinates = [
+export type CanvasCoordinates = [
     Types.Point2,
     Types.Point2,
     Types.Point2,
     Types.Point2
 ];
-export default function getCanvasEllipseCorners(ellipseCanvasPoints: canvasCoordinates): Array<Types.Point2>;
-export {};
+export default function getCanvasEllipseCorners(ellipseCanvasPoints: CanvasCoordinates): Array<Types.Point2>;

package/dist/esm/utilities/math/ellipse/getCanvasEllipseCorners.js

@@ -4,4 +4,3 @@ export default function getCanvasEllipseCorners(ellipseCanvasPoints) {
     const bottomRight = [right[0], bottom[1]];
     return [topLeft, bottomRight];
 }
-//# sourceMappingURL=getCanvasEllipseCorners.js.map

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

@@ -1,3 +1,3 @@
-import pointInEllipse from './pointInEllipse';
+import pointInEllipse, { precalculatePointInEllipse } from './pointInEllipse';
 import getCanvasEllipseCorners from './getCanvasEllipseCorners';
-export { pointInEllipse, getCanvasEllipseCorners };
+export { pointInEllipse, precalculatePointInEllipse, getCanvasEllipseCorners };

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

@@ -1,4 +1,3 @@
-import pointInEllipse from './pointInEllipse';
+import pointInEllipse, { precalculatePointInEllipse } from './pointInEllipse';
 import getCanvasEllipseCorners from './getCanvasEllipseCorners';
-export { pointInEllipse, getCanvasEllipseCorners };
-//# sourceMappingURL=index.js.map
+export { pointInEllipse, precalculatePointInEllipse, getCanvasEllipseCorners };

package/dist/esm/utilities/math/ellipse/pointInEllipse.d.ts

@@ -1,9 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
-declare type Ellipse = {
-    center: Types.Point3;
-    xRadius: number;
-    yRadius: number;
-    zRadius: number;
-};
-export default function pointInEllipse(ellipse: Ellipse, pointLPS: Types.Point3): boolean;
-export {};
+interface Inverts {
+    invXRadiusSq?: number;
+    invYRadiusSq?: number;
+    invZRadiusSq?: number;
+    fast?: boolean;
+    precalculated?: (pointLPS: Types.Point3) => boolean;
+}
+export default function pointInEllipse(ellipse: any, pointLPS: any, inverts?: Inverts): boolean;
+declare const precalculatePointInEllipse: (ellipse: any, inverts?: Inverts) => Inverts;
+export { precalculatePointInEllipse };

package/dist/esm/utilities/math/ellipse/pointInEllipse.js

@@ -1,17 +1,36 @@
-export default function pointInEllipse(ellipse, pointLPS) {
-    const { center: circleCenterWorld, xRadius, yRadius, zRadius } = ellipse;
-    const [x, y, z] = pointLPS;
-    const [x0, y0, z0] = circleCenterWorld;
-    let inside = 0;
-    if (xRadius !== 0) {
-        inside += ((x - x0) * (x - x0)) / (xRadius * xRadius);
+export default function pointInEllipse(ellipse, pointLPS, inverts = {}) {
+    if (!inverts.precalculated) {
+        precalculatePointInEllipse(ellipse, inverts);
     }
-    if (yRadius !== 0) {
-        inside += ((y - y0) * (y - y0)) / (yRadius * yRadius);
-    }
-    if (zRadius !== 0) {
-        inside += ((z - z0) * (z - z0)) / (zRadius * zRadius);
-    }
-    return inside <= 1;
+    return inverts.precalculated(pointLPS);
 }
-//# sourceMappingURL=pointInEllipse.js.map
+const precalculatePointInEllipse = (ellipse, inverts = {}) => {
+    const { xRadius, yRadius, zRadius } = ellipse;
+    if (inverts.invXRadiusSq === undefined ||
+        inverts.invYRadiusSq === undefined ||
+        inverts.invZRadiusSq === undefined) {
+        inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
+        inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
+        inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
+    }
+    const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
+    const { center } = ellipse;
+    const [centerL, centerP, centerS] = center;
+    inverts.precalculated = (pointLPS) => {
+        const dx = pointLPS[0] - centerL;
+        let inside = dx * dx * invXRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dy = pointLPS[1] - centerP;
+        inside += dy * dy * invYRadiusSq;
+        if (inside > 1) {
+            return false;
+        }
+        const dz = pointLPS[2] - centerS;
+        inside += dz * dz * invZRadiusSq;
+        return inside <= 1;
+    };
+    return inverts;
+};
+export { precalculatePointInEllipse };

package/dist/esm/utilities/math/ellipse/pointInEllipsoidWithConstraint.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-declare type ellipsoid = {
+type ellipsoid = {
     center: [number, number, number];
     width: number;
     height: number;

package/dist/esm/utilities/math/ellipse/pointInEllipsoidWithConstraint.js

@@ -1,3 +1,2 @@
 export default function pointInEllipsoidWithConstraint(ellipsoid, point, viewPlane) {
 }
-//# sourceMappingURL=pointInEllipsoidWithConstraint.js.map

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

@@ -1,8 +1,9 @@
-import * as vec2 from './vec2';
+import * as aabb from './aabb';
+import * as BasicStatsCalculator from './basic';
 import * as ellipse from './ellipse';
 import * as lineSegment from './line';
-import * as rectangle from './rectangle';
-import * as polyline from './polyline';
 import * as point from './point';
-import * as BasicStatsCalculator from './basic';
-export { vec2, ellipse, lineSegment, rectangle, polyline, point, BasicStatsCalculator, };
+import * as polyline from './polyline';
+import * as rectangle from './rectangle';
+import * as vec2 from './vec2';
+export { aabb, BasicStatsCalculator, ellipse, lineSegment, point, polyline, rectangle, vec2, };

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

@@ -1,9 +1,9 @@
-import * as vec2 from './vec2';
+import * as aabb from './aabb';
+import * as BasicStatsCalculator from './basic';
 import * as ellipse from './ellipse';
 import * as lineSegment from './line';
-import * as rectangle from './rectangle';
-import * as polyline from './polyline';
 import * as point from './point';
-import * as BasicStatsCalculator from './basic';
-export { vec2, ellipse, lineSegment, rectangle, polyline, point, BasicStatsCalculator, };
-//# sourceMappingURL=index.js.map
+import * as polyline from './polyline';
+import * as rectangle from './rectangle';
+import * as vec2 from './vec2';
+export { aabb, BasicStatsCalculator, ellipse, lineSegment, point, polyline, rectangle, vec2, };

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

@@ -5,4 +5,3 @@ export default function distanceToPoint(lineStart, lineEnd, point) {
     }
     return Math.sqrt(distanceToPointSquared(lineStart, lineEnd, point));
 }
-//# sourceMappingURL=distanceToPoint.js.map

package/dist/esm/utilities/math/line/distanceToPointSquared.js

@@ -1,24 +1,4 @@
-function dist2(p1, p2) {
-    return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
-}
+import distanceToPointSquaredInfo from './distanceToPointSquaredInfo';
 export default function distanceToPointSquared(lineStart, lineEnd, point) {
-    const d2 = dist2(lineStart, lineEnd);
-    if (d2 === 0) {
-        return dist2(point, lineStart);
-    }
-    const t = ((point[0] - lineStart[0]) * (lineEnd[0] - lineStart[0]) +
-        (point[1] - lineStart[1]) * (lineEnd[1] - lineStart[1])) /
-        d2;
-    if (t < 0) {
-        return dist2(point, lineStart);
-    }
-    if (t > 1) {
-        return dist2(point, lineEnd);
-    }
-    const pt = [
-        lineStart[0] + t * (lineEnd[0] - lineStart[0]),
-        lineStart[1] + t * (lineEnd[1] - lineStart[1]),
-    ];
-    return dist2(point, pt);
+    return distanceToPointSquaredInfo(lineStart, lineEnd, point).distanceSquared;
 }
-//# sourceMappingURL=distanceToPointSquared.js.map

package/dist/esm/utilities/math/line/distanceToPointSquaredInfo.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function distanceToPointSquaredInfo(lineStart: Types.Point2, lineEnd: Types.Point2, point: Types.Point2): {
+    point: Types.Point2;
+    distanceSquared: number;
+};

package/dist/esm/utilities/math/line/distanceToPointSquaredInfo.js

@@ -0,0 +1,29 @@
+import * as math from '../';
+export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
+    let closestPoint;
+    const distanceSquared = math.point.distanceToPointSquared(lineStart, lineEnd);
+    if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
+        closestPoint = lineStart;
+    }
+    if (!closestPoint) {
+        const dotProduct = ((point[0] - lineStart[0]) * (lineEnd[0] - lineStart[0]) +
+            (point[1] - lineStart[1]) * (lineEnd[1] - lineStart[1])) /
+            distanceSquared;
+        if (dotProduct < 0) {
+            closestPoint = lineStart;
+        }
+        else if (dotProduct > 1) {
+            closestPoint = lineEnd;
+        }
+        else {
+            closestPoint = [
+                lineStart[0] + dotProduct * (lineEnd[0] - lineStart[0]),
+                lineStart[1] + dotProduct * (lineEnd[1] - lineStart[1]),
+            ];
+        }
+    }
+    return {
+        point: [...closestPoint],
+        distanceSquared: math.point.distanceToPointSquared(point, closestPoint),
+    };
+}

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

@@ -1,4 +1,6 @@
 import distanceToPoint from './distanceToPoint';
 import distanceToPointSquared from './distanceToPointSquared';
+import distanceToPointSquaredInfo from './distanceToPointSquaredInfo';
 import intersectLine from './intersectLine';
-export { distanceToPoint, distanceToPointSquared, intersectLine };
+import isPointOnLineSegment from './isPointOnLineSegment';
+export { distanceToPoint, distanceToPointSquared, distanceToPointSquaredInfo, intersectLine, isPointOnLineSegment, };

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

@@ -1,5 +1,6 @@
 import distanceToPoint from './distanceToPoint';
 import distanceToPointSquared from './distanceToPointSquared';
+import distanceToPointSquaredInfo from './distanceToPointSquaredInfo';
 import intersectLine from './intersectLine';
-export { distanceToPoint, distanceToPointSquared, intersectLine };
-//# sourceMappingURL=index.js.map
+import isPointOnLineSegment from './isPointOnLineSegment';
+export { distanceToPoint, distanceToPointSquared, distanceToPointSquaredInfo, intersectLine, isPointOnLineSegment, };

package/dist/esm/utilities/math/line/intersectLine.js

@@ -39,4 +39,3 @@ export default function intersectLine(line1Start, line1End, line2Start, line2End
     const intersectionPoint = [x, y];
     return intersectionPoint;
 }
-//# sourceMappingURL=intersectLine.js.map

package/dist/esm/utilities/math/line/isPointOnLineSegment.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function isPointOnLineSegment(lineStart: Types.Point2, lineEnd: Types.Point2, point: Types.Point2): boolean;

package/dist/esm/utilities/math/line/isPointOnLineSegment.js

@@ -0,0 +1,18 @@
+const ORIENTATION_TOLERANCE = 1e-2;
+export default function isPointOnLineSegment(lineStart, lineEnd, point) {
+    const minX = lineStart[0] <= lineEnd[0] ? lineStart[0] : lineEnd[0];
+    const maxX = lineStart[0] >= lineEnd[0] ? lineStart[0] : lineEnd[0];
+    const minY = lineStart[1] <= lineEnd[1] ? lineStart[1] : lineEnd[1];
+    const maxY = lineStart[1] >= lineEnd[1] ? lineStart[1] : lineEnd[1];
+    const aabbContainsPoint = point[0] >= minX - ORIENTATION_TOLERANCE &&
+        point[0] <= maxX + ORIENTATION_TOLERANCE &&
+        point[1] >= minY - ORIENTATION_TOLERANCE &&
+        point[1] <= maxY + ORIENTATION_TOLERANCE;
+    if (!aabbContainsPoint) {
+        return false;
+    }
+    const orientation = (lineEnd[1] - lineStart[1]) * (point[0] - lineEnd[0]) -
+        (lineEnd[0] - lineStart[0]) * (point[1] - lineEnd[1]);
+    const absOrientation = orientation >= 0 ? orientation : -orientation;
+    return absOrientation <= ORIENTATION_TOLERANCE;
+}

package/dist/esm/utilities/math/midPoint.js

@@ -13,4 +13,3 @@ const midPoint = (...args) => {
 const midPoint2 = midPoint;
 export default midPoint;
 export { midPoint2 };
-//# sourceMappingURL=midPoint.js.map

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

@@ -1,2 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-export default function distanceToPoint(p1: Types.Point2, p2: Types.Point2): number;
+type Point = Types.Point2 | Types.Point3;
+export default function distanceToPoint(p1: Point, p2: Point): number;
+export {};

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

@@ -1,9 +1,4 @@
+import distanceToPointSquared from './distanceToPointSquared';
 export default function distanceToPoint(p1, p2) {
-    if (p1?.length !== 2 || p2?.length !== 2) {
-        throw Error('points should have 2 elements of [x, y]');
-    }
-    const [x1, y1] = p1;
-    const [x2, y2] = p2;
-    return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+    return Math.sqrt(distanceToPointSquared(p1, p2));
 }
-//# sourceMappingURL=distanceToPoint.js.map

package/dist/esm/utilities/math/point/distanceToPointSquared.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+type Point = Types.Point2 | Types.Point3;
+export default function distanceToPointSquared(p1: Point, p2: Point): number;
+export {};

package/dist/esm/utilities/math/point/distanceToPointSquared.js

@@ -0,0 +1,11 @@
+export default function distanceToPointSquared(p1, p2) {
+    if (p1.length !== p2.length) {
+        throw Error('Both points should have the same dimensionality');
+    }
+    const [x1, y1, z1 = 0] = p1;
+    const [x2, y2, z2 = 0] = p2;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const dz = z2 - z1;
+    return dx * dx + dy * dy + dz * dz;
+}

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

@@ -1,2 +1,3 @@
-import distanceToPoint from './distanceToPoint';
-export { distanceToPoint };
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';
+export { default as mirror } from './mirror';

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

@@ -1,3 +1,3 @@
-import distanceToPoint from './distanceToPoint';
-export { distanceToPoint };
-//# sourceMappingURL=index.js.map
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';
+export { default as mirror } from './mirror';

package/dist/esm/utilities/math/point/mirror.d.ts

@@ -0,0 +1,2 @@
+import { Types } from '@cornerstonejs/core';
+export default function mirror(mirrorPoint: Types.Point2, staticPoint: Types.Point2): Types.Point2;

package/dist/esm/utilities/math/point/mirror.js

@@ -0,0 +1,7 @@
+export default function mirror(mirrorPoint, staticPoint) {
+    const [x1, y1] = mirrorPoint;
+    const [x2, y2] = staticPoint;
+    const newX = 2 * x2 - x1;
+    const newY = 2 * y2 - y1;
+    return [newX, newY];
+}