@cornerstonejs/tools 3.0.2 → 3.0.3

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

@@ -0,0 +1,26 @@
+import { StackViewport, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
+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);
+    }
+    if (viewport instanceof StackViewport) {
+        const imageId = viewport.getCurrentImageId();
+        if (!imageId) {
+            return [];
+        }
+        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);
+    });
+}

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

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

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

@@ -0,0 +1,46 @@
+import { vec3 } from 'gl-matrix';
+import { CONSTANTS, metaData } from '@cornerstonejs/core';
+const { EPSILON } = CONSTANTS;
+const PARALLEL_THRESHOLD = 1 - EPSILON;
+export default function filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection) {
+    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 [];
+    }
+    const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
+    const { focalPoint } = camera;
+    const annotationsWithinSlice = [];
+    for (const annotation of annotationsWithParallelNormals) {
+        const data = annotation.data;
+        const point = data.handles.points[0] || data.contour?.polyline[0];
+        if (!annotation.isVisible) {
+            continue;
+        }
+        const dir = vec3.create();
+        if (!point) {
+            annotationsWithinSlice.push(annotation);
+            continue;
+        }
+        vec3.sub(dir, focalPoint, point);
+        const dot = vec3.dot(dir, viewPlaneNormal);
+        if (Math.abs(dot) < halfSpacingInNormalDirection) {
+            annotationsWithinSlice.push(annotation);
+        }
+    }
+    return annotationsWithinSlice;
+}

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

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getPointInLineOfSightWithCriteria(viewport: Types.IVolumeViewport, worldPos: Types.Point3, targetVolumeId: string, criteriaFunction: (intensity: number, point: Types.Point3) => Types.Point3, stepSize?: number): Types.Point3;
+export declare function getPointsInLineOfSight(viewport: Types.IVolumeViewport, worldPos: Types.Point3, { targetVolumeId, stepSize }: {
+    targetVolumeId: string;
+    stepSize: number;
+}): Types.Point3[];

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

@@ -0,0 +1,49 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+export function getPointInLineOfSightWithCriteria(viewport, worldPos, targetVolumeId, criteriaFunction, stepSize = 0.25) {
+    const points = getPointsInLineOfSight(viewport, worldPos, {
+        targetVolumeId,
+        stepSize,
+    });
+    let pickedPoint;
+    for (const point of points) {
+        const intensity = viewport.getIntensityFromWorld(point);
+        const pointToPick = criteriaFunction(intensity, point);
+        if (pointToPick) {
+            pickedPoint = pointToPick;
+        }
+    }
+    return pickedPoint;
+}
+export function getPointsInLineOfSight(viewport, worldPos, { targetVolumeId, stepSize }) {
+    const camera = viewport.getCamera();
+    const { viewPlaneNormal: normalDirection } = camera;
+    const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId);
+    const step = spacingInNormalDirection * stepSize || 1;
+    const bounds = viewport.getBounds();
+    const points = [];
+    let currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] += normalDirection[0] * step;
+        currentPos[1] += normalDirection[1] * step;
+        currentPos[2] += normalDirection[2] * step;
+    }
+    currentPos = [...worldPos];
+    while (_inBounds(currentPos, bounds)) {
+        points.push([...currentPos]);
+        currentPos[0] -= normalDirection[0] * step;
+        currentPos[1] -= normalDirection[1] * step;
+        currentPos[2] -= normalDirection[2] * step;
+    }
+    return points;
+}
+const _inBounds = function (point, bounds) {
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = bounds;
+    const padding = 10;
+    return (point[0] > xMin + padding &&
+        point[0] < xMax - padding &&
+        point[1] > yMin + padding &&
+        point[1] < yMax - padding &&
+        point[2] > zMin + padding &&
+        point[2] < zMax - padding);
+};

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getWorldWidthAndHeightFromCorners(viewPlaneNormal: Types.Point3, viewUp: Types.Point3, topLeftWorld: Types.Point3, bottomRightWorld: Types.Point3): {
+    worldWidth: number;
+    worldHeight: number;
+};

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

@@ -0,0 +1,18 @@
+import { vec3 } from 'gl-matrix';
+export default function getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, topLeftWorld, bottomRightWorld) {
+    const viewRight = vec3.create();
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const pos1 = vec3.fromValues(...topLeftWorld);
+    const pos2 = vec3.fromValues(...bottomRightWorld);
+    const diagonal = vec3.create();
+    vec3.subtract(diagonal, pos1, pos2);
+    const diagonalLength = vec3.length(diagonal);
+    if (diagonalLength < 0.0001) {
+        return { worldWidth: 0, worldHeight: 0 };
+    }
+    const cosTheta = vec3.dot(diagonal, viewRight) / (diagonalLength * vec3.length(viewRight));
+    const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+    const worldWidth = sinTheta * diagonalLength;
+    const worldHeight = cosTheta * diagonalLength;
+    return { worldWidth, worldHeight };
+}

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

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal: Types.Point3, viewUp: Types.Point3, worldPos1: Types.Point3, worldPos2: Types.Point3): {
+    worldWidth: number;
+    worldHeight: number;
+};

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

@@ -0,0 +1,18 @@
+import { vec3 } from 'gl-matrix';
+export default function getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2) {
+    const viewRight = vec3.create();
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const pos1 = vec3.fromValues(...worldPos1);
+    const pos2 = vec3.fromValues(...worldPos2);
+    const diagonal = vec3.create();
+    vec3.subtract(diagonal, pos1, pos2);
+    const diagonalLength = vec3.length(diagonal);
+    if (diagonalLength < 0.0001) {
+        return { worldWidth: 0, worldHeight: 0 };
+    }
+    const cosTheta = vec3.dot(diagonal, viewRight) / (diagonalLength * vec3.length(viewRight));
+    const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+    const worldWidth = sinTheta * diagonalLength;
+    const worldHeight = cosTheta * diagonalLength;
+    return { worldWidth, worldHeight };
+}

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

@@ -0,0 +1,19 @@
+import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
+import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
+import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
+import getWorldWidthAndHeightFromTwoPoints from './getWorldWidthAndHeightFromTwoPoints';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight } from './getPointInLineOfSightWithCriteria';
+import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
+declare const _default: {
+    filterAnnotationsWithinSlice: typeof filterAnnotationsWithinSlice;
+    getWorldWidthAndHeightFromCorners: typeof getWorldWidthAndHeightFromCorners;
+    getWorldWidthAndHeightFromTwoPoints: typeof getWorldWidthAndHeightFromTwoPoints;
+    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;
+    getPointsInLineOfSight: typeof getPointsInLineOfSight;
+};
+export default _default;
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, getWorldWidthAndHeightFromTwoPoints, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

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

@@ -0,0 +1,18 @@
+import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
+import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
+import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
+import getWorldWidthAndHeightFromTwoPoints from './getWorldWidthAndHeightFromTwoPoints';
+import { getPointInLineOfSightWithCriteria, getPointsInLineOfSight, } from './getPointInLineOfSightWithCriteria';
+import { isPlaneIntersectingAABB } from './isPlaneIntersectingAABB';
+import { filterAnnotationsWithinSamePlane } from './filterAnnotationsWithinPlane';
+export default {
+    filterAnnotationsWithinSlice,
+    getWorldWidthAndHeightFromCorners,
+    getWorldWidthAndHeightFromTwoPoints,
+    filterAnnotationsForDisplay,
+    getPointInLineOfSightWithCriteria,
+    isPlaneIntersectingAABB,
+    filterAnnotationsWithinSamePlane,
+    getPointsInLineOfSight,
+};
+export { filterAnnotationsWithinSlice, getWorldWidthAndHeightFromCorners, getWorldWidthAndHeightFromTwoPoints, filterAnnotationsForDisplay, getPointInLineOfSightWithCriteria, isPlaneIntersectingAABB, filterAnnotationsWithinSamePlane, getPointsInLineOfSight, };

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

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

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

@@ -0,0 +1,5 @@
+import smoothAnnotation from './smoothAnnotation';
+export default {
+    smoothAnnotation,
+};
+export { smoothAnnotation };

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

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

@@ -0,0 +1,22 @@
+import { interpolateBasis as d3InterpolateBasis, quantize as d3Quantize, } from 'd3-interpolate';
+import { zip as d3Zip } from 'd3-array';
+function isPoints3D(points) {
+    return points[0]?.length === 3;
+}
+export function interpolatePoints(originalPoints, knotsIndexes) {
+    if (!knotsIndexes ||
+        knotsIndexes.length === 0 ||
+        knotsIndexes.length === originalPoints.length) {
+        return originalPoints;
+    }
+    const n = knotsIndexes[knotsIndexes.length - 1] - knotsIndexes[0] + 1;
+    const xInterpolator = d3InterpolateBasis(knotsIndexes.map((k) => originalPoints[k][0]));
+    const yInterpolator = d3InterpolateBasis(knotsIndexes.map((k) => originalPoints[k][1]));
+    if (isPoints3D(originalPoints)) {
+        const zInterpolator = d3InterpolateBasis(knotsIndexes.map((k) => originalPoints[k][2]));
+        return (d3Zip(d3Quantize(xInterpolator, n), d3Quantize(yInterpolator, n), d3Quantize(zInterpolator, n)));
+    }
+    else {
+        return (d3Zip(d3Quantize(xInterpolator, n), d3Quantize(yInterpolator, n)));
+    }
+}

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

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

@@ -0,0 +1,41 @@
+import { interpolatePoints } from './algorithms/bspline';
+function getContinuousUniformDistributionValues(minDistributionDistance, closedInterval) {
+    const result = [];
+    const [intervalIni, intervalEnd] = closedInterval;
+    const intervalSize = intervalEnd - intervalIni + 1;
+    const intensity = Math.floor(intervalSize / minDistributionDistance);
+    let x = 0;
+    let continuosDistributionValue = Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
+    while (continuosDistributionValue <= intervalEnd) {
+        result.push(continuosDistributionValue);
+        x++;
+        continuosDistributionValue =
+            Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
+    }
+    return result;
+}
+export default function interpolateSegmentPoints(points, iniIndex, endIndex, knotsRatioPercentage) {
+    const segmentSize = endIndex - iniIndex + 1;
+    const amountOfKnots = Math.floor((knotsRatioPercentage / 100) * segmentSize) ?? 1;
+    const minKnotDistance = Math.floor(segmentSize / amountOfKnots) ?? 1;
+    if (isNaN(segmentSize) || !segmentSize || !minKnotDistance) {
+        return points;
+    }
+    if (segmentSize / minKnotDistance < 2) {
+        return points;
+    }
+    const interpolationIniIndex = Math.max(0, iniIndex);
+    const interpolationEndIndex = Math.min(points.length - 1, endIndex);
+    const segmentPointsUnchangedBeg = points.slice(0, interpolationIniIndex);
+    const segmentPointsUnchangedEnd = points.slice(interpolationEndIndex + 1, points.length);
+    const knotsIndexes = getContinuousUniformDistributionValues(minKnotDistance, [
+        interpolationIniIndex,
+        interpolationEndIndex,
+    ]);
+    const interpolatedPoints = interpolatePoints(points, knotsIndexes);
+    return [
+        ...segmentPointsUnchangedBeg,
+        ...interpolatedPoints,
+        ...segmentPointsUnchangedEnd,
+    ];
+}

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[];

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

@@ -0,0 +1,91 @@
+import { point } from '../math';
+import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
+export function shouldSmooth(configuration, annotation) {
+    if (annotation?.autoGenerated) {
+        return false;
+    }
+    const shouldSmooth = configuration?.smoothing?.smoothOnAdd === true ||
+        configuration?.smoothing?.smoothOnEdit === true;
+    return shouldSmooth;
+}
+function isEqualByProximity(pointA, pointB) {
+    return point.distanceToPoint(pointA, pointB) < 0.001;
+}
+function isEqual(pointA, pointB) {
+    return point.distanceToPoint(pointA, pointB) === 0;
+}
+function findMatchIndexes(points, otherPoints) {
+    for (let i = 0; i < points.length; i++) {
+        for (let j = 0; j < otherPoints.length; j++) {
+            if (isEqual(points[i], otherPoints[j])) {
+                return [i, j];
+            }
+        }
+    }
+}
+function followingIndex(index, size, direction) {
+    return (index + size + direction) % size;
+}
+function circularFindNextIndexBy(listParams, otherListParams, criteria, direction) {
+    const [, indexDelimiter, points] = listParams;
+    const [, otherIndexDelimiter, otherPoints] = otherListParams;
+    const pointsLength = points.length;
+    const otherPointsLength = otherPoints.length;
+    let startIndex = listParams[0];
+    let otherStartIndex = otherListParams[0];
+    if (!points[startIndex] ||
+        !otherPoints[otherStartIndex] ||
+        !points[indexDelimiter] ||
+        !otherPoints[otherIndexDelimiter]) {
+        return [undefined, undefined];
+    }
+    while (startIndex !== indexDelimiter &&
+        otherStartIndex !== otherIndexDelimiter) {
+        if (criteria(otherPoints[otherStartIndex], points[startIndex])) {
+            return [startIndex, otherStartIndex];
+        }
+        startIndex = followingIndex(startIndex, pointsLength, direction);
+        otherStartIndex = followingIndex(otherStartIndex, otherPointsLength, direction);
+    }
+    return [undefined, undefined];
+}
+function findChangedSegment(points, previousPoints) {
+    const [firstMatchIndex, previousFirstMatchIndex] = findMatchIndexes(points, previousPoints) || [];
+    const toBeNotEqualCriteria = (pointA, pointB) => isEqualByProximity(pointA, pointB) === false;
+    const [lowDiffIndex, lowOtherDiffIndex] = circularFindNextIndexBy([
+        followingIndex(firstMatchIndex, points.length, 1),
+        firstMatchIndex,
+        points,
+    ], [
+        followingIndex(previousFirstMatchIndex, previousPoints.length, 1),
+        previousFirstMatchIndex,
+        previousPoints,
+    ], toBeNotEqualCriteria, 1);
+    const [highIndex] = circularFindNextIndexBy([followingIndex(lowDiffIndex, points.length, -1), lowDiffIndex, points], [
+        followingIndex(lowOtherDiffIndex, previousPoints.length, -1),
+        lowOtherDiffIndex,
+        previousPoints,
+    ], toBeNotEqualCriteria, -1);
+    return [lowDiffIndex, highIndex];
+}
+export function getInterpolatedPoints(configuration, points, pointsOfReference) {
+    const { interpolation, smoothing } = configuration;
+    const result = points;
+    if (interpolation) {
+        const { knotsRatioPercentageOnAdd, knotsRatioPercentageOnEdit, smoothOnAdd = false, smoothOnEdit = false, } = smoothing;
+        const knotsRatioPercentage = pointsOfReference
+            ? knotsRatioPercentageOnEdit
+            : knotsRatioPercentageOnAdd;
+        const isEnabled = pointsOfReference ? smoothOnEdit : smoothOnAdd;
+        if (isEnabled) {
+            const [changedIniIndex, changedEndIndex] = pointsOfReference
+                ? findChangedSegment(points, pointsOfReference)
+                : [0, points.length - 1];
+            if (!points[changedIniIndex] || !points[changedEndIndex]) {
+                return points;
+            }
+            return (interpolateSegmentPoints(points, changedIniIndex, changedEndIndex, knotsRatioPercentage));
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+export declare function pointInSurroundingSphereCallback(imageData: vtkImageData, circlePoints: [Types.Point3, Types.Point3], callback: (args: {
+    value: unknown;
+    index: number;
+    pointIJK: Types.Point3;
+    pointLPS: Types.Point3;
+}) => void, viewport?: Types.IVolumeViewport): void;

package/dist/esm/utilities/pointInSurroundingSphereCallback.js

@@ -0,0 +1,71 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { pointInSphere } from './math/sphere';
+import { getBoundingBoxAroundShape } from './boundingBox';
+const { transformWorldToIndex } = csUtils;
+export function pointInSurroundingSphereCallback(imageData, circlePoints, callback, viewport) {
+    const { boundsIJK, centerWorld, radiusWorld } = _getBounds(circlePoints, imageData, viewport);
+    const sphereObj = {
+        center: centerWorld,
+        radius: radiusWorld,
+    };
+    const dimensions = imageData.getDimensions();
+    const voxelManager = csUtils.VoxelManager.createScalarVolumeVoxelManager({
+        dimensions: dimensions,
+        scalarData: imageData.getPointData().getScalars().getData(),
+    });
+    voxelManager.forEach(callback, {
+        boundsIJK,
+        isInObject: (pointLPS) => pointInSphere(sphereObj, pointLPS),
+        imageData,
+    });
+}
+function _getBounds(circlePoints, imageData, viewport) {
+    const [bottom, top] = circlePoints;
+    const centerWorld = vec3.fromValues((bottom[0] + top[0]) / 2, (bottom[1] + top[1]) / 2, (bottom[2] + top[2]) / 2);
+    const radiusWorld = vec3.distance(bottom, top) / 2;
+    let boundsIJK;
+    if (!viewport) {
+        const centerIJK = transformWorldToIndex(imageData, centerWorld);
+        const spacings = imageData.getSpacing();
+        const minSpacing = Math.min(...spacings);
+        const maxRadiusIJK = Math.ceil(radiusWorld / minSpacing);
+        boundsIJK = [
+            [centerIJK[0] - maxRadiusIJK, centerIJK[0] + maxRadiusIJK],
+            [centerIJK[1] - maxRadiusIJK, centerIJK[1] + maxRadiusIJK],
+            [centerIJK[2] - maxRadiusIJK, centerIJK[2] + maxRadiusIJK],
+        ];
+        return {
+            boundsIJK,
+            centerWorld: centerWorld,
+            radiusWorld,
+        };
+    }
+    boundsIJK = _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld);
+    return {
+        boundsIJK,
+        centerWorld: centerWorld,
+        radiusWorld,
+    };
+}
+function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
+    const [bottom, top] = circlePoints;
+    const dimensions = imageData.getDimensions();
+    const camera = viewport.getCamera();
+    const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
+    const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
+    const viewRight = vec3.create();
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const topLeftWorld = vec3.create();
+    const bottomRightWorld = vec3.create();
+    vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
+    vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
+    vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+    const sphereCornersIJK = [
+        transformWorldToIndex(imageData, topLeftWorld),
+        (transformWorldToIndex(imageData, bottomRightWorld)),
+    ];
+    const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
+    return boundsIJK;
+}

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

@@ -0,0 +1 @@
+export declare function pointToString(point: any, decimals?: number): string;

package/dist/esm/utilities/pointToString.js

@@ -0,0 +1,8 @@
+export function pointToString(point, decimals = 5) {
+    return (parseFloat(point[0]).toFixed(decimals) +
+        ',' +
+        parseFloat(point[1]).toFixed(decimals) +
+        ',' +
+        parseFloat(point[2]).toFixed(decimals) +
+        ',');
+}