@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,119 @@
+import { utilities } from '@cornerstonejs/core';
+import Calculator from './Calculator';
+const { PointsManager } = utilities;
+export default class BasicStatsCalculator extends Calculator {
+    static { this.max = [-Infinity]; }
+    static { this.min = [Infinity]; }
+    static { this.sum = [0]; }
+    static { this.count = 0; }
+    static { this.maxIJK = null; }
+    static { this.maxLPS = null; }
+    static { this.minIJK = null; }
+    static { this.minLPS = null; }
+    static { this.runMean = [0]; }
+    static { this.m2 = [0]; }
+    static { this.pointsInShape = PointsManager.create3(1024); }
+    static statsInit(options) {
+        if (!options.storePointData) {
+            BasicStatsCalculator.pointsInShape = null;
+        }
+    }
+    static { this.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = 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]);
+        }
+        if (this.pointsInShape && pointLPS) {
+            this.pointsInShape?.push(pointLPS);
+        }
+        const newArray = Array.isArray(newValue) ? newValue : [newValue];
+        this.count += 1;
+        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);
+            if (value < this.min[idx]) {
+                this.min[idx] = value;
+                if (idx === 0) {
+                    this.minIJK = pointIJK;
+                    this.minLPS = pointLPS;
+                }
+            }
+            if (value > this.max[idx]) {
+                this.max[idx] = value;
+                if (idx === 0) {
+                    this.maxIJK = pointIJK;
+                    this.maxLPS = pointLPS;
+                }
+            }
+        });
+    }; }
+    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,
+                pointIJK: this.maxIJK,
+                pointLPS: this.maxLPS,
+            },
+            min: {
+                name: 'min',
+                label: 'Min Pixel',
+                value: singleArrayAsNumber(this.min),
+                unit,
+                pointIJK: this.minIJK,
+                pointLPS: this.minLPS,
+            },
+            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;
+        this.maxIJK = null;
+        this.maxLPS = null;
+        this.minIJK = null;
+        this.minLPS = null;
+        this.pointsInShape = PointsManager.create3(1024);
+        return named;
+    }; }
+}
+function singleArrayAsNumber(val) {
+    return val.length === 1 ? val[0] : val;
+}

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

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

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

@@ -0,0 +1,3 @@
+class Calculator {
+}
+export default Calculator;

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { canvasCoordinates } from './_types';
+export default function getCanvasCircleCorners(circleCanvasPoints: canvasCoordinates): Array<Types.Point2>;

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

@@ -0,0 +1,8 @@
+import { distanceToPoint } from '../point';
+export default function getCanvasCircleCorners(circleCanvasPoints) {
+    const [center, end] = circleCanvasPoints;
+    const radius = distanceToPoint(center, end);
+    const topLeft = [center[0] - radius, center[1] - radius];
+    const bottomRight = [center[0] + radius, center[1] + radius];
+    return [topLeft, bottomRight];
+}

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

@@ -0,0 +1,2 @@
+import type { canvasCoordinates } from './_types';
+export default function getCanvasCircleRadius(circleCanvasPoints: canvasCoordinates): number;

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

@@ -0,0 +1,5 @@
+import { distanceToPoint } from '../point';
+export default function getCanvasCircleRadius(circleCanvasPoints) {
+    const [center, end] = circleCanvasPoints;
+    return distanceToPoint(center, end);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+export default function getCanvasEllipseCorners(ellipseCanvasPoints) {
+    const [bottom, top, left, right] = ellipseCanvasPoints;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    return [topLeft, bottomRight];
+}

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+export default function pointInEllipse(ellipse, pointLPS, inverts = {}) {
+    if (!inverts.precalculated) {
+        precalculatePointInEllipse(ellipse, inverts);
+    }
+    return inverts.precalculated(pointLPS);
+}
+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

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+type ellipsoid = {
+    center: [number, number, number];
+    width: number;
+    height: number;
+    depth: number;
+};
+export default function pointInEllipsoidWithConstraint(ellipsoid: ellipsoid, point: Types.Point3, viewPlane: Types.Point3): void;
+export {};

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

@@ -0,0 +1,2 @@
+export default function pointInEllipsoidWithConstraint(ellipsoid, point, viewPlane) {
+}

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import distanceToPointSquared from './distanceToPointSquared';
+export default function distanceToPoint(lineStart, lineEnd, point) {
+    if (lineStart.length !== 2 || lineEnd.length !== 2 || point.length !== 2) {
+        throw Error('lineStart, lineEnd, and point should have 2 elements of [x, y]');
+    }
+    return Math.sqrt(distanceToPointSquared(lineStart, lineEnd, point));
+}

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

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

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

@@ -0,0 +1,4 @@
+import distanceToPointSquaredInfo from './distanceToPointSquaredInfo';
+export default function distanceToPointSquared(lineStart, lineEnd, point) {
+    return distanceToPointSquaredInfo(lineStart, lineEnd, point).distanceSquared;
+}

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 { distanceToPointSquared } from '../point';
+export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
+    let closestPoint;
+    const distanceSquared = 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: distanceToPointSquared(point, closestPoint),
+    };
+}

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

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+function sign(x) {
+    return typeof x === 'number'
+        ? x
+            ? x < 0
+                ? -1
+                : 1
+            : x === x
+                ? 0
+                : NaN
+        : NaN;
+}
+export default function intersectLine(line1Start, line1End, line2Start, line2End) {
+    const [x1, y1] = line1Start;
+    const [x2, y2] = line1End;
+    const [x3, y3] = line2Start;
+    const [x4, y4] = line2End;
+    const a1 = y2 - y1;
+    const b1 = x1 - x2;
+    const c1 = x2 * y1 - x1 * y2;
+    const r3 = a1 * x3 + b1 * y3 + c1;
+    const r4 = a1 * x4 + b1 * y4 + c1;
+    if (r3 !== 0 && r4 !== 0 && sign(r3) === sign(r4)) {
+        return;
+    }
+    const a2 = y4 - y3;
+    const b2 = x3 - x4;
+    const c2 = x4 * y3 - x3 * y4;
+    const r1 = a2 * x1 + b2 * y1 + c2;
+    const r2 = a2 * x2 + b2 * y2 + c2;
+    if (r1 !== 0 && r2 !== 0 && sign(r1) === sign(r2)) {
+        return;
+    }
+    const denom = a1 * b2 - a2 * b1;
+    let num;
+    num = b1 * c2 - b2 * c1;
+    const x = num / denom;
+    num = a2 * c1 - a1 * c2;
+    const y = num / denom;
+    const intersectionPoint = [x, y];
+    return intersectionPoint;
+}

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.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+declare const midPoint: (...args: (Types.Point2 | Types.Point3)[]) => Types.Point2 | Types.Point3;
+declare const midPoint2: (...args: Types.Point2[]) => Types.Point2;
+export default midPoint;
+export { midPoint2 };

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

@@ -0,0 +1,15 @@
+const midPoint = (...args) => {
+    const ret = args[0].length === 2 ? [0, 0] : [0, 0, 0];
+    const len = args.length;
+    for (const arg of args) {
+        ret[0] += arg[0] / len;
+        ret[1] += arg[1] / len;
+        if (ret.length === 3) {
+            ret[2] += arg[2] / len;
+        }
+    }
+    return ret;
+};
+const midPoint2 = midPoint;
+export default midPoint;
+export { midPoint2 };

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

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

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

@@ -0,0 +1,4 @@
+import distanceToPointSquared from './distanceToPointSquared';
+export default function distanceToPoint(p1, p2) {
+    return Math.sqrt(distanceToPointSquared(p1, p2));
+}

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

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

@@ -0,0 +1,3 @@
+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 type { 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];
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PlanarFreehandROICommonData } from './planarFreehandROIInternalTypes';
+declare const addCanvasPointsToArray: (element: HTMLDivElement, canvasPoints: Types.Point2[], newCanvasPoint: Types.Point2, commonData: PlanarFreehandROICommonData) => number;
+export default addCanvasPointsToArray;

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

@@ -0,0 +1,38 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { vec2, vec3 } from 'gl-matrix';
+const addCanvasPointsToArray = (element, canvasPoints, newCanvasPoint, commonData) => {
+    const { xDir, yDir, spacing } = commonData;
+    const enabledElement = getEnabledElement(element);
+    const { viewport } = enabledElement;
+    if (!canvasPoints.length) {
+        canvasPoints.push(newCanvasPoint);
+        console.log('>>>>> !canvasPoints. :: RETURN');
+        return 1;
+    }
+    const lastWorldPos = viewport.canvasToWorld(canvasPoints[canvasPoints.length - 1]);
+    const newWorldPos = viewport.canvasToWorld(newCanvasPoint);
+    const worldPosDiff = vec3.create();
+    vec3.subtract(worldPosDiff, newWorldPos, lastWorldPos);
+    const xDist = Math.abs(vec3.dot(worldPosDiff, xDir));
+    const yDist = Math.abs(vec3.dot(worldPosDiff, yDir));
+    const numPointsToAdd = Math.max(Math.floor(xDist / spacing[0]), Math.floor(yDist / spacing[0]));
+    if (numPointsToAdd > 1) {
+        const lastCanvasPoint = canvasPoints[canvasPoints.length - 1];
+        const canvasDist = vec2.dist(lastCanvasPoint, newCanvasPoint);
+        const canvasDir = vec2.create();
+        vec2.subtract(canvasDir, newCanvasPoint, lastCanvasPoint);
+        vec2.set(canvasDir, canvasDir[0] / canvasDist, canvasDir[1] / canvasDist);
+        const distPerPoint = canvasDist / numPointsToAdd;
+        for (let i = 1; i <= numPointsToAdd; i++) {
+            canvasPoints.push([
+                lastCanvasPoint[0] + distPerPoint * canvasDir[0] * i,
+                lastCanvasPoint[1] + distPerPoint * canvasDir[1] * i,
+            ]);
+        }
+    }
+    else {
+        canvasPoints.push(newCanvasPoint);
+    }
+    return numPointsToAdd;
+};
+export default addCanvasPointsToArray;

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function areLineSegmentsIntersecting(p1: Types.Point2, q1: Types.Point2, p2: Types.Point2, q2: Types.Point2): boolean;

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

@@ -0,0 +1,55 @@
+export default function areLineSegmentsIntersecting(p1, q1, p2, q2) {
+    let result = false;
+    const line1MinX = p1[0] < q1[0] ? p1[0] : q1[0];
+    const line1MinY = p1[1] < q1[1] ? p1[1] : q1[1];
+    const line1MaxX = p1[0] > q1[0] ? p1[0] : q1[0];
+    const line1MaxY = p1[1] > q1[1] ? p1[1] : q1[1];
+    const line2MinX = p2[0] < q2[0] ? p2[0] : q2[0];
+    const line2MinY = p2[1] < q2[1] ? p2[1] : q2[1];
+    const line2MaxX = p2[0] > q2[0] ? p2[0] : q2[0];
+    const line2MaxY = p2[1] > q2[1] ? p2[1] : q2[1];
+    if (line1MinX > line2MaxX ||
+        line1MaxX < line2MinX ||
+        line1MinY > line2MaxY ||
+        line1MaxY < line2MinY) {
+        return false;
+    }
+    const orient = [
+        orientation(p1, q1, p2),
+        orientation(p1, q1, q2),
+        orientation(p2, q2, p1),
+        orientation(p2, q2, q1),
+    ];
+    if (orient[0] !== orient[1] && orient[2] !== orient[3]) {
+        return true;
+    }
+    if (orient[0] === 0 && onSegment(p1, p2, q1)) {
+        result = true;
+    }
+    else if (orient[1] === 0 && onSegment(p1, q2, q1)) {
+        result = true;
+    }
+    else if (orient[2] === 0 && onSegment(p2, p1, q2)) {
+        result = true;
+    }
+    else if (orient[3] === 0 && onSegment(p2, q1, q2)) {
+        result = true;
+    }
+    return result;
+}
+function orientation(p, q, r) {
+    const orientationValue = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);
+    if (orientationValue === 0) {
+        return 0;
+    }
+    return orientationValue > 0 ? 1 : 2;
+}
+function onSegment(p, q, r) {
+    if (q[0] <= Math.max(p[0], r[0]) &&
+        q[0] >= Math.min(p[0], r[0]) &&
+        q[1] <= Math.max(p[1], r[1]) &&
+        q[1] >= Math.min(p[1], r[1])) {
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+declare function mergePolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[];
+declare function subtractPolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[][];
+export { mergePolylines, subtractPolylines };