@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,8 +1,23 @@
-import { getFirstIntersectionWithPolyline, getClosestIntersectionWithPolyline, } from './getIntersectionWithPolyline';
+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 calculateAreaOfPoints from './calculateAreaOfPoints';
-export { getFirstIntersectionWithPolyline, getClosestIntersectionWithPolyline, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, calculateAreaOfPoints, };
-//# sourceMappingURL=index.js.map
+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

@@ -1,10 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
-declare type PlanarFreehandROIDrawData = {
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+type PlanarFreehandROIDrawData = {
     polylineIndex: number;
     canvasPoints: Types.Point2[];
+    contourHoleProcessingEnabled: boolean;
 };
-declare type PlanarFreehandROIEditData = {
+type PlanarFreehandROIEditData = {
     prevCanvasPoints: Types.Point2[];
     editCanvasPoints: Types.Point2[];
     fusedCanvasPoints: Types.Point2[];
@@ -12,7 +13,7 @@ declare type PlanarFreehandROIEditData = {
     editIndex: number;
     snapIndex?: number;
 };
-declare type PlanarFreehandROICommonData = {
+type PlanarFreehandROICommonData = {
     annotation: PlanarFreehandROIAnnotation;
     viewportIdsToRender: string[];
     spacing: Types.Point2;
@@ -20,4 +21,4 @@ declare type PlanarFreehandROICommonData = {
     yDir: Types.Point3;
     movingTextBox?: boolean;
 };
-export { PlanarFreehandROIDrawData, PlanarFreehandROIEditData, PlanarFreehandROICommonData, };
+export type { PlanarFreehandROIDrawData, PlanarFreehandROIEditData, PlanarFreehandROICommonData, };

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

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

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

@@ -30,4 +30,3 @@ const pointCanProjectOnLine = (p, p1, p2, proximity) => {
     return true;
 };
 export default pointCanProjectOnLine;
-//# sourceMappingURL=pointCanProjectOnLine.js.map

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

@@ -3,4 +3,3 @@ const pointsAreWithinCloseContourProximity = (p1, p2, closeContourProximity) =>
     return vec2.dist(p1, p2) < closeContourProximity;
 };
 export default pointsAreWithinCloseContourProximity;
-//# sourceMappingURL=pointsAreWithinCloseContourProximity.js.map

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.js

@@ -32,4 +32,3 @@ export default function distanceToPoint(rect, point) {
     });
     return minDistance;
 }
-//# sourceMappingURL=distanceToPoint.js.map

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
 export default function pointInSphere(sphere, pointLPS) {
     const { center, radius } = sphere;
-    return ((pointLPS[0] - center[0]) ** 2 +
-        (pointLPS[1] - center[1]) ** 2 +
-        (pointLPS[2] - center[2]) ** 2 <=
-        radius ** 2);
+    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);
 }
-//# sourceMappingURL=pointInSphere.js.map

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

@@ -15,4 +15,3 @@ function _distanceBetween(p1, p2) {
     const [x2, y2] = p2;
     return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
 }
-//# sourceMappingURL=findClosestPoint.js.map

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

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

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

@@ -1 +1 @@
-export default function clip(a: any, b: any, box: any, da?: any, db?: any): 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

@@ -66,4 +66,3 @@ export default function clip(a, b, box, da, db) {
     }
     return OUTSIDE;
 }
-//# sourceMappingURL=liangBarksyClip.js.map

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/orientation/getOrientationStringLPS.d.ts

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

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

@@ -39,4 +39,3 @@ export default function getOrientationStringLPS(vector) {
     }
     return orientation;
 }
-//# sourceMappingURL=getOrientationStringLPS.js.map

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

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

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

@@ -8,4 +8,3 @@ export default function invertOrientationStringLPS(orientationString) {
     inverted = inverted.toUpperCase();
     return inverted;
 }
-//# sourceMappingURL=invertOrientationStringLPS.js.map

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

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

package/dist/esm/utilities/planar/filterAnnotationsForDisplay.js

@@ -1,30 +1,23 @@
 import { StackViewport, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
-export default function filterAnnotationsForDisplay(viewport, annotations) {
-    if (viewport instanceof StackViewport) {
-        const imageId = viewport.getCurrentImageId();
-        const colonIndex = imageId.indexOf(':');
-        const imageURI = imageId.substring(colonIndex + 1);
-        return annotations.filter((annotation) => {
-            if (!annotation.isVisible) {
-                return false;
-            }
-            const imageId = annotation.metadata.referencedImageId;
-            if (imageId === undefined) {
-                return false;
-            }
-            const colonIndex = imageId.indexOf(':');
-            const referenceImageURI = imageId.substring(colonIndex + 1);
-            return referenceImageURI === imageURI;
-        });
-    }
-    else if (viewport instanceof VolumeViewport) {
+export default function filterAnnotationsForDisplay(viewport, annotations, filterOptions = {}) {
+    if (viewport instanceof VolumeViewport) {
         const camera = viewport.getCamera();
         const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera);
         return filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection);
     }
-    else {
-        throw new Error(`Viewport Type ${viewport.type} not supported`);
+    if (viewport instanceof StackViewport) {
+        const imageId = viewport.getCurrentImageId();
+        const colonIndex = imageId.indexOf(':');
+        filterOptions.imageURI = imageId.substring(colonIndex + 1);
     }
+    return annotations.filter((annotation) => {
+        if (!annotation.isVisible) {
+            return false;
+        }
+        if (annotation.data.isCanvasAnnotation) {
+            return true;
+        }
+        return viewport.isReferenceViewable(annotation.metadata, filterOptions);
+    });
 }
-//# sourceMappingURL=filterAnnotationsForDisplay.js.map

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotations } from '../../types';
+export declare function filterAnnotationsWithinSamePlane(annotations: Annotations, camera: Types.ICamera): Annotations;

package/dist/esm/utilities/planar/filterAnnotationsWithinPlane.js

@@ -0,0 +1,26 @@
+import { vec3 } from 'gl-matrix';
+import { CONSTANTS, metaData } from '@cornerstonejs/core';
+const { EPSILON } = CONSTANTS;
+const PARALLEL_THRESHOLD = 1 - EPSILON;
+export function filterAnnotationsWithinSamePlane(annotations, camera) {
+    const { viewPlaneNormal } = camera;
+    const annotationsWithParallelNormals = annotations.filter((td) => {
+        let annotationViewPlaneNormal = td.metadata.viewPlaneNormal;
+        if (!annotationViewPlaneNormal) {
+            const { referencedImageId } = td.metadata;
+            const { imageOrientationPatient } = metaData.get('imagePlaneModule', referencedImageId);
+            const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+            const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+            annotationViewPlaneNormal = vec3.create();
+            vec3.cross(annotationViewPlaneNormal, rowCosineVec, colCosineVec);
+            td.metadata.viewPlaneNormal = annotationViewPlaneNormal;
+        }
+        const isParallel = Math.abs(vec3.dot(viewPlaneNormal, annotationViewPlaneNormal)) >
+            PARALLEL_THRESHOLD;
+        return annotationViewPlaneNormal && isParallel;
+    });
+    if (!annotationsWithParallelNormals.length) {
+        return [];
+    }
+    return annotationsWithParallelNormals;
+}

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import { Annotations } from '../../types';
+import type { Annotations } from '../../types';
 export default function filterAnnotationsWithinSlice(annotations: Annotations, camera: Types.ICamera, spacingInNormalDirection: number): Annotations;

package/dist/esm/utilities/planar/filterAnnotationsWithinSlice.js

@@ -40,4 +40,3 @@ export default function filterAnnotationsWithinSlice(annotations, camera, spacin
     }
     return annotationsWithinSlice;
 }
-//# sourceMappingURL=filterAnnotationsWithinSlice.js.map

package/dist/esm/utilities/planar/getPointInLineOfSightWithCriteria.js

@@ -36,4 +36,3 @@ const _inBounds = function (point, bounds) {
         point[2] > zMin &&
         point[2] < zMax);
 };
-//# sourceMappingURL=getPointInLineOfSightWithCriteria.js.map

package/dist/esm/utilities/planar/getWorldWidthAndHeightFromCorners.js

@@ -16,4 +16,3 @@ export default function getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewU
     const worldHeight = cosTheta * diagonalLength;
     return { worldWidth, worldHeight };
 }
-//# sourceMappingURL=getWorldWidthAndHeightFromCorners.js.map

package/dist/esm/utilities/planar/getWorldWidthAndHeightFromTwoPoints.js

@@ -16,4 +16,3 @@ export default function getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, vie
     const worldHeight = cosTheta * diagonalLength;
     return { worldWidth, worldHeight };
 }
-//# sourceMappingURL=getWorldWidthAndHeightFromTwoPoints.js.map

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

@@ -2,11 +2,15 @@ import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
 import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 declare const _default: {
     filterAnnotationsWithinSlice: typeof filterAnnotationsWithinSlice;
     getWorldWidthAndHeightFromCorners: typeof getWorldWidthAndHeightFromCorners;
     filterAnnotationsForDisplay: typeof filterAnnotationsForDisplay;
     getPointInLineOfSightWithCriteria: typeof getPointInLineOfSightWithCriteria;
+    isPlaneIntersectingAABB: (origin: any, normal: any, minX: any, minY: any, minZ: any, maxX: any, maxY: any, maxZ: any) => boolean;
+    filterAnnotationsWithinSamePlane: typeof filterAnnotationsWithinSamePlane;
 };
 export default _default;
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, };
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };

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

@@ -2,11 +2,14 @@ import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
 import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
 import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
 import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
 export default {
     filterAnnotationsWithinSlice,
     getWorldWidthAndHeightFromCorners,
     filterAnnotationsForDisplay,
     getPointInLineOfSightWithCriteria,
+    isPlaneIntersectingAABB,
+    filterAnnotationsWithinSamePlane,
 };
-export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, };
-//# sourceMappingURL=index.js.map
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, };

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

@@ -0,0 +1 @@
+export declare const isPlaneIntersectingAABB: (origin: any, normal: any, minX: any, minY: any, minZ: any, maxX: any, maxY: any, maxZ: any) => boolean;

package/dist/esm/utilities/planar/isPlaneIntersectingAABB.js

@@ -0,0 +1,27 @@
+import { vec3 } from 'gl-matrix';
+export const isPlaneIntersectingAABB = (origin, normal, minX, minY, minZ, maxX, maxY, maxZ) => {
+    const vertices = [
+        vec3.fromValues(minX, minY, minZ),
+        vec3.fromValues(maxX, minY, minZ),
+        vec3.fromValues(minX, maxY, minZ),
+        vec3.fromValues(maxX, maxY, minZ),
+        vec3.fromValues(minX, minY, maxZ),
+        vec3.fromValues(maxX, minY, maxZ),
+        vec3.fromValues(minX, maxY, maxZ),
+        vec3.fromValues(maxX, maxY, maxZ),
+    ];
+    const normalVec = vec3.fromValues(normal[0], normal[1], normal[2]);
+    const originVec = vec3.fromValues(origin[0], origin[1], origin[2]);
+    const planeDistance = -vec3.dot(normalVec, originVec);
+    let initialSign = null;
+    for (const vertex of vertices) {
+        const distance = vec3.dot(normalVec, vertex) + planeDistance;
+        if (initialSign === null) {
+            initialSign = Math.sign(distance);
+        }
+        else if (Math.sign(distance) !== initialSign) {
+            return true;
+        }
+    }
+    return false;
+};

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

@@ -1,6 +1,6 @@
-import interpolateAnnotation from './interpolateAnnotation';
+import smoothAnnotation from './smoothAnnotation';
 declare const _default: {
-    interpolateAnnotation: typeof interpolateAnnotation;
+    smoothAnnotation: typeof smoothAnnotation;
 };
 export default _default;
-export { interpolateAnnotation };
+export { smoothAnnotation };

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

@@ -1,6 +1,5 @@
-import interpolateAnnotation from './interpolateAnnotation';
+import smoothAnnotation from './smoothAnnotation';
 export default {
-    interpolateAnnotation,
+    smoothAnnotation,
 };
-export { interpolateAnnotation };
-//# sourceMappingURL=index.js.map
+export { smoothAnnotation };

package/dist/esm/utilities/planarFreehandROITool/interpolation/algorithms/bspline.d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export declare function interpolatePoints(originalPoints: (Types.Point2 | Types.Point3)[], knotsIndexes: number[]): (Types.Point2 | Types.Point3)[];

package/dist/esm/utilities/planarFreehandROITool/interpolation/algorithms/bspline.js

@@ -20,4 +20,3 @@ export function interpolatePoints(originalPoints, knotsIndexes) {
         return (d3Zip(d3Quantize(xInterpolator, n), d3Quantize(yInterpolator, n)));
     }
 }
-//# sourceMappingURL=bspline.js.map

package/dist/esm/utilities/planarFreehandROITool/interpolation/interpolateSegmentPoints.d.ts

@@ -1,2 +1,2 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export default function interpolateSegmentPoints(points: (Types.Point2 | Types.Point3)[], iniIndex: number, endIndex: number, knotsRatioPercentage: number): (Types.Point2 | Types.Point3)[];

package/dist/esm/utilities/planarFreehandROITool/interpolation/interpolateSegmentPoints.js

@@ -39,4 +39,3 @@ export default function interpolateSegmentPoints(points, iniIndex, endIndex, kno
         ...segmentPointsUnchangedEnd,
     ];
 }
-//# sourceMappingURL=interpolateSegmentPoints.js.map

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.d.ts

@@ -0,0 +1,6 @@
+import type { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+export type SmoothOptions = {
+    knotsRatioPercentage: number;
+    loop: number;
+};
+export default function smoothAnnotation(annotation: PlanarFreehandROIAnnotation, options?: SmoothOptions): boolean;

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js

@@ -0,0 +1,56 @@
+import { mat4, vec3 } from 'gl-matrix';
+import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
+function shouldPreventInterpolation(annotation, options) {
+    const knotsRatioPercentage = options?.knotsRatioPercentage || 30;
+    if (!annotation?.data?.contour?.polyline?.length ||
+        knotsRatioPercentage <= 0) {
+        return true;
+    }
+    return false;
+}
+function rotateMatrix(normal, focal) {
+    const mat = mat4.create();
+    const eye = vec3.add(vec3.create(), focal, normal);
+    const up = Math.abs(normal[0]) > 0.1
+        ? vec3.fromValues(-normal[1], normal[0], 0)
+        : vec3.fromValues(0, -normal[2], normal[1]);
+    mat4.lookAt(mat, focal, eye, up);
+    return mat;
+}
+function rotate(list, count = Math.floor(Math.random() * (list.length - 1))) {
+    if (count === 0) {
+        return 0;
+    }
+    const srcList = [...list];
+    const { length } = list;
+    for (let i = 0; i < length; i++) {
+        list[i] = srcList[(i + count + length) % length];
+    }
+    return count;
+}
+export default function smoothAnnotation(annotation, options) {
+    if (shouldPreventInterpolation(annotation, options)) {
+        return false;
+    }
+    const { viewPlaneNormal } = annotation.metadata;
+    const { closed, polyline } = annotation.data.contour;
+    const rotateMat = rotateMatrix(viewPlaneNormal, annotation.data.contour.polyline[0]);
+    const canvasPoints = annotation.data.contour.polyline.map((p) => {
+        const planeP = vec3.transformMat4(vec3.create(), p, rotateMat);
+        return [planeP[0], planeP[1]];
+    });
+    let rotation = closed ? rotate(canvasPoints) : 0;
+    let interpolatedCanvasPoints = (interpolateSegmentPoints(canvasPoints, 0, canvasPoints.length, options?.knotsRatioPercentage || 30));
+    if (interpolatedCanvasPoints === canvasPoints) {
+        return false;
+    }
+    rotate(interpolatedCanvasPoints, -rotation);
+    for (let i = 1; i < options?.loop; i++) {
+        rotation = closed ? rotate(interpolatedCanvasPoints) : 0;
+        interpolatedCanvasPoints = (interpolateSegmentPoints(interpolatedCanvasPoints, 0, canvasPoints.length, options?.knotsRatioPercentage || 30));
+        rotate(interpolatedCanvasPoints, -rotation);
+    }
+    const unRotate = mat4.invert(mat4.create(), rotateMat);
+    annotation.data.contour.polyline = (interpolatedCanvasPoints.map((p) => vec3.transformMat4([0, 0, 0], [...p, 0], unRotate)));
+    return true;
+}

package/dist/esm/utilities/planarFreehandROITool/smoothPoints.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function shouldSmooth(configuration: Record<string, {
+    smoothOnAdd: boolean;
+    smoothOnEdit: boolean;
+}>, annotation?: any): boolean;
+export declare function getInterpolatedPoints(configuration: Record<string, {
+    smoothOnAdd: boolean;
+    smoothOnEdit: boolean;
+    knotsRatioPercentageOnAdd: number;
+    knotsRatioPercentageOnEdit: number;
+}>, points: Types.Point2[], pointsOfReference?: Types.Point2[]): Types.Point2[];