@cornerstonejs/tools 3.0.2 → 3.0.4

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

@@ -0,0 +1,186 @@
+import * as mathPoint from '../point';
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import containsPoint from './containsPoint';
+import getNormal2 from './getNormal2';
+import { glMatrix, vec3 } from 'gl-matrix';
+import getLinesIntersection from './getLinesIntersection';
+var PolylinePointType;
+(function (PolylinePointType) {
+    PolylinePointType[PolylinePointType["Vertex"] = 0] = "Vertex";
+    PolylinePointType[PolylinePointType["Intersection"] = 1] = "Intersection";
+})(PolylinePointType || (PolylinePointType = {}));
+var PolylinePointPosition;
+(function (PolylinePointPosition) {
+    PolylinePointPosition[PolylinePointPosition["Outside"] = -1] = "Outside";
+    PolylinePointPosition[PolylinePointPosition["Edge"] = 0] = "Edge";
+    PolylinePointPosition[PolylinePointPosition["Inside"] = 1] = "Inside";
+})(PolylinePointPosition || (PolylinePointPosition = {}));
+var PolylinePointDirection;
+(function (PolylinePointDirection) {
+    PolylinePointDirection[PolylinePointDirection["Exiting"] = -1] = "Exiting";
+    PolylinePointDirection[PolylinePointDirection["Unknown"] = 0] = "Unknown";
+    PolylinePointDirection[PolylinePointDirection["Entering"] = 1] = "Entering";
+})(PolylinePointDirection || (PolylinePointDirection = {}));
+function ensuresNextPointers(polylinePoints) {
+    for (let i = 0, len = polylinePoints.length; i < len; i++) {
+        const currentPoint = polylinePoints[i];
+        if (!currentPoint.next) {
+            currentPoint.next = polylinePoints[i === len - 1 ? 0 : i + 1];
+        }
+    }
+}
+function getSourceAndTargetPointsList(targetPolyline, sourcePolyline) {
+    const targetPolylinePoints = [];
+    const sourcePolylinePoints = [];
+    const sourceIntersectionsCache = new Map();
+    const isFirstPointInside = containsPoint(sourcePolyline, targetPolyline[0]);
+    let intersectionPointDirection = isFirstPointInside
+        ? PolylinePointDirection.Exiting
+        : PolylinePointDirection.Entering;
+    for (let i = 0, len = targetPolyline.length; i < len; i++) {
+        const p1 = targetPolyline[i];
+        const pointInside = containsPoint(sourcePolyline, p1);
+        const vertexPoint = {
+            type: PolylinePointType.Vertex,
+            coordinates: p1,
+            position: pointInside
+                ? PolylinePointPosition.Inside
+                : PolylinePointPosition.Outside,
+            visited: false,
+            next: null,
+        };
+        targetPolylinePoints.push(vertexPoint);
+        const q1 = targetPolyline[i === len - 1 ? 0 : i + 1];
+        const intersectionsInfo = getLineSegmentIntersectionsIndexes(sourcePolyline, p1, q1).map((intersectedLineSegment) => {
+            const sourceLineSegmentId = intersectedLineSegment[0];
+            const p2 = sourcePolyline[intersectedLineSegment[0]];
+            const q2 = sourcePolyline[intersectedLineSegment[1]];
+            const intersectionCoordinate = getLinesIntersection(p1, q1, p2, q2);
+            const targetStartPointDistSquared = mathPoint.distanceToPointSquared(p1, intersectionCoordinate);
+            return {
+                sourceLineSegmentId,
+                coordinate: intersectionCoordinate,
+                targetStartPointDistSquared,
+            };
+        });
+        intersectionsInfo.sort((left, right) => left.targetStartPointDistSquared - right.targetStartPointDistSquared);
+        intersectionsInfo.forEach((intersectionInfo) => {
+            const { sourceLineSegmentId, coordinate: intersectionCoordinate } = intersectionInfo;
+            const targetEdgePoint = {
+                type: PolylinePointType.Intersection,
+                coordinates: intersectionCoordinate,
+                position: PolylinePointPosition.Edge,
+                direction: intersectionPointDirection,
+                visited: false,
+                next: null,
+            };
+            const sourceEdgePoint = {
+                ...targetEdgePoint,
+                direction: PolylinePointDirection.Unknown,
+                cloned: true,
+            };
+            if (intersectionPointDirection === PolylinePointDirection.Entering) {
+                targetEdgePoint.next = sourceEdgePoint;
+            }
+            else {
+                sourceEdgePoint.next = targetEdgePoint;
+            }
+            let sourceIntersectionPoints = sourceIntersectionsCache.get(sourceLineSegmentId);
+            if (!sourceIntersectionPoints) {
+                sourceIntersectionPoints = [];
+                sourceIntersectionsCache.set(sourceLineSegmentId, sourceIntersectionPoints);
+            }
+            targetPolylinePoints.push(targetEdgePoint);
+            sourceIntersectionPoints.push(sourceEdgePoint);
+            intersectionPointDirection *= -1;
+        });
+    }
+    for (let i = 0, len = sourcePolyline.length; i < len; i++) {
+        const lineSegmentId = i;
+        const p1 = sourcePolyline[i];
+        const vertexPoint = {
+            type: PolylinePointType.Vertex,
+            coordinates: p1,
+            visited: false,
+            next: null,
+        };
+        sourcePolylinePoints.push(vertexPoint);
+        const sourceIntersectionPoints = sourceIntersectionsCache.get(lineSegmentId);
+        if (!sourceIntersectionPoints?.length) {
+            continue;
+        }
+        sourceIntersectionPoints
+            .map((intersectionPoint) => ({
+            intersectionPoint,
+            lineSegStartDistSquared: mathPoint.distanceToPointSquared(p1, intersectionPoint.coordinates),
+        }))
+            .sort((left, right) => left.lineSegStartDistSquared - right.lineSegStartDistSquared)
+            .map(({ intersectionPoint }) => intersectionPoint)
+            .forEach((intersectionPoint) => sourcePolylinePoints.push(intersectionPoint));
+    }
+    ensuresNextPointers(targetPolylinePoints);
+    ensuresNextPointers(sourcePolylinePoints);
+    return { targetPolylinePoints, sourcePolylinePoints };
+}
+function getUnvisitedOutsidePoint(polylinePoints) {
+    for (let i = 0, len = polylinePoints.length; i < len; i++) {
+        const point = polylinePoints[i];
+        if (!point.visited && point.position === PolylinePointPosition.Outside) {
+            return point;
+        }
+    }
+}
+function mergePolylines(targetPolyline, sourcePolyline) {
+    const targetNormal = getNormal2(targetPolyline);
+    const sourceNormal = getNormal2(sourcePolyline);
+    const dotNormals = vec3.dot(sourceNormal, targetNormal);
+    if (!glMatrix.equals(1, dotNormals)) {
+        sourcePolyline = sourcePolyline.slice().reverse();
+    }
+    const { targetPolylinePoints } = getSourceAndTargetPointsList(targetPolyline, sourcePolyline);
+    const startPoint = getUnvisitedOutsidePoint(targetPolylinePoints);
+    if (!startPoint) {
+        return targetPolyline.slice();
+    }
+    const mergedPolyline = [startPoint.coordinates];
+    let currentPoint = startPoint.next;
+    while (currentPoint !== startPoint) {
+        if (currentPoint.type === PolylinePointType.Intersection &&
+            currentPoint.cloned) {
+            currentPoint = currentPoint.next;
+            continue;
+        }
+        mergedPolyline.push(currentPoint.coordinates);
+        currentPoint = currentPoint.next;
+    }
+    return mergedPolyline;
+}
+function subtractPolylines(targetPolyline, sourcePolyline) {
+    const targetNormal = getNormal2(targetPolyline);
+    const sourceNormal = getNormal2(sourcePolyline);
+    const dotNormals = vec3.dot(sourceNormal, targetNormal);
+    if (!glMatrix.equals(-1, dotNormals)) {
+        sourcePolyline = sourcePolyline.slice().reverse();
+    }
+    const { targetPolylinePoints } = getSourceAndTargetPointsList(targetPolyline, sourcePolyline);
+    let startPoint = null;
+    const subtractedPolylines = [];
+    while ((startPoint = getUnvisitedOutsidePoint(targetPolylinePoints))) {
+        const subtractedPolyline = [startPoint.coordinates];
+        let currentPoint = startPoint.next;
+        startPoint.visited = true;
+        while (currentPoint !== startPoint) {
+            currentPoint.visited = true;
+            if (currentPoint.type === PolylinePointType.Intersection &&
+                currentPoint.cloned) {
+                currentPoint = currentPoint.next;
+                continue;
+            }
+            subtractedPolyline.push(currentPoint.coordinates);
+            currentPoint = currentPoint.next;
+        }
+        subtractedPolylines.push(subtractedPolyline);
+    }
+    return subtractedPolylines;
+}
+export { mergePolylines, subtractPolylines };

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function containsPoint(polyline: Types.Point2[], point: Types.Point2, options?: {
+    closed?: boolean;
+    holes?: Types.Point2[][];
+}): boolean;

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

@@ -0,0 +1,39 @@
+import isClosed from './isClosed';
+export default function containsPoint(polyline, point, options = {
+    closed: undefined,
+}) {
+    if (polyline.length < 3) {
+        return false;
+    }
+    const numPolylinePoints = polyline.length;
+    let numIntersections = 0;
+    const { closed, holes } = options;
+    if (holes?.length) {
+        for (const hole of holes) {
+            if (containsPoint(hole, point)) {
+                return false;
+            }
+        }
+    }
+    const shouldClose = !(closed === undefined ? isClosed(polyline) : closed);
+    const maxSegmentIndex = polyline.length - (shouldClose ? 1 : 2);
+    for (let i = 0; i <= maxSegmentIndex; i++) {
+        const p1 = polyline[i];
+        const p2Index = i === numPolylinePoints - 1 ? 0 : i + 1;
+        const p2 = polyline[p2Index];
+        const maxX = p1[0] >= p2[0] ? p1[0] : p2[0];
+        const maxY = p1[1] >= p2[1] ? p1[1] : p2[1];
+        const minY = p1[1] <= p2[1] ? p1[1] : p2[1];
+        const mayIntersectLineSegment = point[0] <= maxX && point[1] >= minY && point[1] < maxY;
+        if (mayIntersectLineSegment) {
+            const isVerticalLine = p1[0] === p2[0];
+            let intersects = isVerticalLine;
+            if (!intersects) {
+                const xIntersection = ((point[1] - p1[1]) * (p2[0] - p1[0])) / (p2[1] - p1[1]) + p1[0];
+                intersects = point[0] <= xIntersection;
+            }
+            numIntersections += intersects ? 1 : 0;
+        }
+    }
+    return !!(numIntersections % 2);
+}

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

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

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

@@ -0,0 +1,9 @@
+import containsPoint from './containsPoint';
+export default function containsPoints(polyline, points) {
+    for (let i = 0, numPoint = points.length; i < numPoint; i++) {
+        if (!containsPoint(polyline, points[i])) {
+            return false;
+        }
+    }
+    return true;
+}

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

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

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

@@ -0,0 +1,46 @@
+import * as mathLine from '../line';
+const DEFAULT_EPSILON = 0.1;
+export default function decimate(polyline, epsilon = DEFAULT_EPSILON) {
+    const numPoints = polyline.length;
+    if (numPoints < 3) {
+        return polyline;
+    }
+    const epsilonSquared = epsilon * epsilon;
+    const partitionQueue = [[0, numPoints - 1]];
+    const polylinePointFlags = new Array(numPoints).fill(false);
+    let numDecimatedPoints = 2;
+    polylinePointFlags[0] = true;
+    polylinePointFlags[numPoints - 1] = true;
+    while (partitionQueue.length) {
+        const [startIndex, endIndex] = partitionQueue.pop();
+        if (endIndex - startIndex === 1) {
+            continue;
+        }
+        const startPoint = polyline[startIndex];
+        const endPoint = polyline[endIndex];
+        let maxDistSquared = -Infinity;
+        let maxDistIndex = -1;
+        for (let i = startIndex + 1; i < endIndex; i++) {
+            const currentPoint = polyline[i];
+            const distSquared = mathLine.distanceToPointSquared(startPoint, endPoint, currentPoint);
+            if (distSquared > maxDistSquared) {
+                maxDistSquared = distSquared;
+                maxDistIndex = i;
+            }
+        }
+        if (maxDistSquared < epsilonSquared) {
+            continue;
+        }
+        polylinePointFlags[maxDistIndex] = true;
+        numDecimatedPoints++;
+        partitionQueue.push([maxDistIndex, endIndex]);
+        partitionQueue.push([startIndex, maxDistIndex]);
+    }
+    const decimatedPolyline = new Array(numDecimatedPoints);
+    for (let srcIndex = 0, dstIndex = 0; srcIndex < numPoints; srcIndex++) {
+        if (polylinePointFlags[srcIndex]) {
+            decimatedPolyline[dstIndex++] = polyline[srcIndex];
+        }
+    }
+    return decimatedPolyline;
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getAABB(polyline: Types.Point2[] | Types.Point3[] | number[], options?: {
+    numDimensions: number;
+}): Types.AABB2 | Types.AABB3;

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

@@ -0,0 +1,40 @@
+export default function getAABB(polyline, options) {
+    let polylineToUse = polyline;
+    const numDimensions = options?.numDimensions || 2;
+    const is3D = numDimensions === 3;
+    if (!Array.isArray(polyline[0])) {
+        const currentPolyline = polyline;
+        const totalPoints = currentPolyline.length / numDimensions;
+        polylineToUse = new Array(currentPolyline.length / numDimensions);
+        for (let i = 0, len = totalPoints; i < len; i++) {
+            polylineToUse[i] = [
+                currentPolyline[i * numDimensions],
+                currentPolyline[i * numDimensions + 1],
+            ];
+            if (is3D) {
+                polylineToUse[i].push(currentPolyline[i * numDimensions + 2]);
+            }
+        }
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let minZ = Infinity;
+    let maxZ = -Infinity;
+    polylineToUse = polylineToUse;
+    for (let i = 0, len = polylineToUse.length; i < len; i++) {
+        const [x, y, z] = polylineToUse[i];
+        minX = minX < x ? minX : x;
+        minY = minY < y ? minY : y;
+        maxX = maxX > x ? maxX : x;
+        maxY = maxY > y ? maxY : y;
+        if (is3D) {
+            minZ = minZ < z ? minZ : z;
+            maxZ = maxZ > z ? maxZ : z;
+        }
+    }
+    return is3D
+        ? { minX, maxX, minY, maxY, minZ, maxZ }
+        : { minX, maxX, minY, maxY };
+}

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

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

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

@@ -0,0 +1,10 @@
+export default function getArea(points) {
+    const n = points.length;
+    let area = 0.0;
+    let j = n - 1;
+    for (let i = 0; i < n; i++) {
+        area += (points[j][0] + points[i][0]) * (points[j][1] - points[i][1]);
+        j = i;
+    }
+    return Math.abs(area / 2.0);
+}

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getClosestLineSegmentIntersection(points: Types.Point2[], p1: Types.Point2, q1: Types.Point2, closed?: boolean): {
+    segment: Types.Point2;
+    distance: number;
+} | undefined;

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

@@ -0,0 +1,44 @@
+import { vec2 } from 'gl-matrix';
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+export default function getClosestLineSegmentIntersection(points, p1, q1, closed = true) {
+    let initialQ2Index;
+    let p2Index;
+    if (closed) {
+        p2Index = points.length - 1;
+        initialQ2Index = 0;
+    }
+    else {
+        p2Index = 0;
+        initialQ2Index = 1;
+    }
+    const intersections = [];
+    for (let q2Index = initialQ2Index; q2Index < points.length; q2Index++) {
+        const p2 = points[p2Index];
+        const q2 = points[q2Index];
+        if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+            intersections.push([p2Index, q2Index]);
+        }
+        p2Index = q2Index;
+    }
+    if (intersections.length === 0) {
+        return;
+    }
+    const distances = [];
+    intersections.forEach((intersection) => {
+        const intersectionPoints = [
+            points[intersection[0]],
+            points[intersection[1]],
+        ];
+        const midpoint = [
+            (intersectionPoints[0][0] + intersectionPoints[1][0]) / 2,
+            (intersectionPoints[0][1] + intersectionPoints[1][1]) / 2,
+        ];
+        distances.push(vec2.distance(midpoint, p1));
+    });
+    const minDistance = Math.min(...distances);
+    const indexOfMinDistance = distances.indexOf(minDistance);
+    return {
+        segment: intersections[indexOfMinDistance],
+        distance: minDistance,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getFirstLineSegmentIntersectionIndexes(points: Types.Point2[], p1: Types.Point2, q1: Types.Point2, closed?: boolean): Types.Point2 | undefined;

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

@@ -0,0 +1,21 @@
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+export default function getFirstLineSegmentIntersectionIndexes(points, p1, q1, closed = true) {
+    let initialI;
+    let j;
+    if (closed) {
+        j = points.length - 1;
+        initialI = 0;
+    }
+    else {
+        j = 0;
+        initialI = 1;
+    }
+    for (let i = initialI; i < points.length; i++) {
+        const p2 = points[j];
+        const q2 = points[i];
+        if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+            return [j, i];
+        }
+        j = i;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getLineSegmentIntersectionsCoordinates(points: Types.Point2[], p1: Types.Point2, q1: Types.Point2, closed?: boolean): Types.Point2[];

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

@@ -0,0 +1,13 @@
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import getLinesIntersection from './getLinesIntersection';
+export default function getLineSegmentIntersectionsCoordinates(points, p1, q1, closed = true) {
+    const result = [];
+    const polylineIndexes = getLineSegmentIntersectionsIndexes(points, p1, q1, closed);
+    for (let i = 0; i < polylineIndexes.length; i++) {
+        const p2 = points[polylineIndexes[i][0]];
+        const q2 = points[polylineIndexes[i][1]];
+        const intersection = getLinesIntersection(p1, q1, p2, q2);
+        result.push(intersection);
+    }
+    return result;
+}

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

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

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

@@ -0,0 +1,15 @@
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+export default function getLineSegmentIntersectionsIndexes(polyline, p1, q1, closed = true) {
+    const intersections = [];
+    const numPoints = polyline.length;
+    const maxI = numPoints - (closed ? 1 : 2);
+    for (let i = 0; i <= maxI; i++) {
+        const p2 = polyline[i];
+        const j = i === numPoints - 1 ? 0 : i + 1;
+        const q2 = polyline[j];
+        if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+            intersections.push([i, j]);
+        }
+    }
+    return intersections;
+}

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

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

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

@@ -0,0 +1,51 @@
+import * as mathLine from '../line';
+const PARALLEL_LINES_TOLERANCE = 1e-2;
+export default function getLinesIntersection(p1, q1, p2, q2) {
+    const diffQ1P1 = [q1[0] - p1[0], q1[1] - p1[1]];
+    const diffQ2P2 = [q2[0] - p2[0], q2[1] - p2[1]];
+    const denominator = diffQ2P2[1] * diffQ1P1[0] - diffQ2P2[0] * diffQ1P1[1];
+    const absDenominator = denominator >= 0 ? denominator : -denominator;
+    if (absDenominator < PARALLEL_LINES_TOLERANCE) {
+        const line1AABB = [
+            p1[0] < q1[0] ? p1[0] : q1[0],
+            p1[0] > q1[0] ? p1[0] : q1[0],
+            p1[1] < q1[1] ? p1[1] : q1[1],
+            p1[1] > q1[1] ? p1[1] : q1[1],
+        ];
+        const line2AABB = [
+            p2[0] < q2[0] ? p2[0] : q2[0],
+            p2[0] > q2[0] ? p2[0] : q2[0],
+            p2[1] < q2[1] ? p2[1] : q2[1],
+            p2[1] > q2[1] ? p2[1] : q2[1],
+        ];
+        const aabbIntersects = line1AABB[0] <= line2AABB[1] &&
+            line1AABB[1] >= line2AABB[0] &&
+            line1AABB[2] <= line2AABB[3] &&
+            line1AABB[3] >= line2AABB[2];
+        if (!aabbIntersects) {
+            return;
+        }
+        const overlap = mathLine.isPointOnLineSegment(p1, q1, p2) ||
+            mathLine.isPointOnLineSegment(p1, q1, q2) ||
+            mathLine.isPointOnLineSegment(p2, q2, p1);
+        if (!overlap) {
+            return;
+        }
+        const minX = line1AABB[0] > line2AABB[0] ? line1AABB[0] : line2AABB[0];
+        const maxX = line1AABB[1] < line2AABB[1] ? line1AABB[1] : line2AABB[1];
+        const minY = line1AABB[2] > line2AABB[2] ? line1AABB[2] : line2AABB[2];
+        const maxY = line1AABB[3] < line2AABB[3] ? line1AABB[3] : line2AABB[3];
+        const midX = (minX + maxX) * 0.5;
+        const midY = (minY + maxY) * 0.5;
+        return [midX, midY];
+    }
+    let a = p1[1] - p2[1];
+    let b = p1[0] - p2[0];
+    const numerator1 = diffQ2P2[0] * a - diffQ2P2[1] * b;
+    const numerator2 = diffQ1P1[0] * a - diffQ1P1[1] * b;
+    a = numerator1 / denominator;
+    b = numerator2 / denominator;
+    const resultX = p1[0] + a * diffQ1P1[0];
+    const resultY = p1[1] + a * diffQ1P1[1];
+    return [resultX, resultY];
+}

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

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

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

@@ -0,0 +1,5 @@
+import getSignedArea from './getSignedArea';
+export default function getNormal2(polyline) {
+    const area = getSignedArea(polyline);
+    return [0, 0, area / Math.abs(area)];
+}

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

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

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

@@ -0,0 +1,25 @@
+import { vec3 } from 'gl-matrix';
+function _getAreaVector(polyline) {
+    const vecArea = vec3.create();
+    const refPoint = polyline[0];
+    for (let i = 0, len = polyline.length; i < len; i++) {
+        const p1 = polyline[i];
+        const p2Index = i === len - 1 ? 0 : i + 1;
+        const p2 = polyline[p2Index];
+        const aX = p1[0] - refPoint[0];
+        const aY = p1[1] - refPoint[1];
+        const aZ = p1[2] - refPoint[2];
+        const bX = p2[0] - refPoint[0];
+        const bY = p2[1] - refPoint[1];
+        const bZ = p2[2] - refPoint[2];
+        vecArea[0] += aY * bZ - aZ * bY;
+        vecArea[1] += aZ * bX - aX * bZ;
+        vecArea[2] += aX * bY - aY * bX;
+    }
+    vec3.scale(vecArea, vecArea, 0.5);
+    return vecArea;
+}
+export default function getNormal3(polyline) {
+    const vecArea = _getAreaVector(polyline);
+    return vec3.normalize(vecArea, vecArea);
+}

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

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

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

@@ -0,0 +1,19 @@
+export default function getSignedArea(polyline) {
+    if (polyline.length < 3) {
+        return 0;
+    }
+    const refPoint = polyline[0];
+    let area = 0;
+    for (let i = 0, len = polyline.length; i < len; i++) {
+        const p1 = polyline[i];
+        const p2Index = i === len - 1 ? 0 : i + 1;
+        const p2 = polyline[p2Index];
+        const aX = p1[0] - refPoint[0];
+        const aY = p1[1] - refPoint[1];
+        const bX = p2[0] - refPoint[0];
+        const bY = p2[1] - refPoint[1];
+        area += aX * bY - aY * bX;
+    }
+    area *= 0.5;
+    return area;
+}

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

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+declare const getSubPixelSpacingAndXYDirections: (viewport: Types.IStackViewport | Types.IVolumeViewport, subPixelResolution: number) => {
+    spacing: Types.Point2;
+    xDir: Types.Point3;
+    yDir: Types.Point3;
+};
+export default getSubPixelSpacingAndXYDirections;