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

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.js

@@ -0,0 +1,17 @@
+import { state } from '../../stateManagement/segmentation';
+export function removeContourSegmentationAnnotation(annotation) {
+    if (!annotation.data.segmentation) {
+        throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');
+    }
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = state.getSegmentation(segmentationId);
+    const { annotationUIDsMap } = segmentation?.representationData.CONTOUR || {};
+    const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
+    if (!annotationsUIDsSet) {
+        return;
+    }
+    annotationsUIDsSet.delete(annotation.annotationUID);
+    if (!annotationsUIDsSet.size) {
+        annotationUIDsMap.delete(segmentIndex);
+    }
+}

package/dist/esm/utilities/contours/AnnotationToPointData.d.ts

@@ -0,0 +1,11 @@
+declare class AnnotationToPointData {
+    static TOOL_NAMES: Record<string, any>;
+    constructor();
+    static convert(annotation: any, index: any, metadataProvider: any): {
+        ReferencedROINumber: any;
+        ROIDisplayColor: number[];
+        ContourSequence: any;
+    };
+    static register(toolClass: any): void;
+}
+export default AnnotationToPointData;

package/dist/esm/utilities/contours/AnnotationToPointData.js

@@ -0,0 +1,38 @@
+import RectangleROIStartEndThreshold from './RectangleROIStartEndThreshold';
+function validateAnnotation(annotation) {
+    if (!annotation?.data) {
+        throw new Error('Tool data is empty');
+    }
+    if (!annotation.metadata || annotation.metadata.referencedImageId) {
+        throw new Error('Tool data is not associated with any imageId');
+    }
+}
+class AnnotationToPointData {
+    static { this.TOOL_NAMES = {}; }
+    constructor() {
+    }
+    static convert(annotation, index, metadataProvider) {
+        validateAnnotation(annotation);
+        const { toolName } = annotation.metadata;
+        const toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
+        if (!toolClass) {
+            throw new Error(`Unknown tool type: ${toolName}, cannot convert to RTSSReport`);
+        }
+        const ContourSequence = toolClass.getContourSequence(annotation, metadataProvider);
+        const color = [
+            Math.floor(Math.random() * 255),
+            Math.floor(Math.random() * 255),
+            Math.floor(Math.random() * 255),
+        ];
+        return {
+            ReferencedROINumber: index + 1,
+            ROIDisplayColor: color,
+            ContourSequence,
+        };
+    }
+    static register(toolClass) {
+        AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
+    }
+}
+AnnotationToPointData.register(RectangleROIStartEndThreshold);
+export default AnnotationToPointData;

package/dist/esm/utilities/contours/RectangleROIStartEndThreshold.d.ts

@@ -0,0 +1,6 @@
+declare class RectangleROIStartEndThreshold {
+    static toolName: string;
+    constructor();
+    static getContourSequence(toolData: any, metadataProvider: any): any;
+}
+export default RectangleROIStartEndThreshold;

package/dist/esm/utilities/contours/RectangleROIStartEndThreshold.js

@@ -0,0 +1,40 @@
+class RectangleROIStartEndThreshold {
+    constructor() {
+    }
+    static getContourSequence(toolData, metadataProvider) {
+        const { data } = toolData;
+        const { projectionPoints, projectionPointsImageIds } = data.cachedStats;
+        return projectionPoints.map((point, index) => {
+            const ContourData = getPointData(point);
+            const ContourImageSequence = getContourImageSequence(projectionPointsImageIds[index], metadataProvider);
+            return {
+                NumberOfContourPoints: ContourData.length / 3,
+                ContourImageSequence,
+                ContourGeometricType: 'CLOSED_PLANAR',
+                ContourData,
+            };
+        });
+    }
+}
+RectangleROIStartEndThreshold.toolName = 'RectangleROIStartEndThreshold';
+function getPointData(points) {
+    const orderedPoints = [
+        ...points[0],
+        ...points[1],
+        ...points[3],
+        ...points[2],
+    ];
+    const pointsArray = orderedPoints.flat();
+    const pointsArrayWithPrecision = pointsArray.map((point) => {
+        return point.toFixed(2);
+    });
+    return pointsArrayWithPrecision;
+}
+function getContourImageSequence(imageId, metadataProvider) {
+    const sopCommon = metadataProvider.get('sopCommonModule', imageId);
+    return {
+        ReferencedSOPClassUID: sopCommon.sopClassUID,
+        ReferencedSOPInstanceUID: sopCommon.sopInstanceUID,
+    };
+}
+export default RectangleROIStartEndThreshold;

package/dist/esm/utilities/contours/areCoplanarContours.d.ts

@@ -0,0 +1,2 @@
+import { ContourAnnotation } from '../../types/ContourAnnotation';
+export default function areCoplanarContours(firstAnnotation: ContourAnnotation, secondAnnotation: ContourAnnotation): boolean;

package/dist/esm/utilities/contours/areCoplanarContours.js

@@ -0,0 +1,15 @@
+import { glMatrix, vec3 } from 'gl-matrix';
+export default function areCoplanarContours(firstAnnotation, secondAnnotation) {
+    const { viewPlaneNormal: firstViewPlaneNormal } = firstAnnotation.metadata;
+    const { viewPlaneNormal: secondViewPlaneNormal } = secondAnnotation.metadata;
+    const dot = vec3.dot(firstViewPlaneNormal, secondViewPlaneNormal);
+    const parallelPlanes = glMatrix.equals(1, Math.abs(dot));
+    if (!parallelPlanes) {
+        return false;
+    }
+    const { polyline: firstPolyline } = firstAnnotation.data.contour;
+    const { polyline: secondPolyline } = secondAnnotation.data.contour;
+    const firstDistance = vec3.dot(firstViewPlaneNormal, firstPolyline[0]);
+    const secondDistance = vec3.dot(firstViewPlaneNormal, secondPolyline[0]);
+    return glMatrix.equals(firstDistance, secondDistance);
+}

package/dist/esm/utilities/contours/calculatePerimeter.d.ts

@@ -0,0 +1,2 @@
+declare function calculatePerimeter(polyline: number[][], closed: boolean): number;
+export default calculatePerimeter;

package/dist/esm/utilities/contours/calculatePerimeter.js

@@ -0,0 +1,16 @@
+function calculatePerimeter(polyline, closed) {
+    let perimeter = 0;
+    for (let i = 0; i < polyline.length - 1; i++) {
+        const point1 = polyline[i];
+        const point2 = polyline[i + 1];
+        perimeter += Math.sqrt(Math.pow(point2[0] - point1[0], 2) + Math.pow(point2[1] - point1[1], 2));
+    }
+    if (closed) {
+        const firstPoint = polyline[0];
+        const lastPoint = polyline[polyline.length - 1];
+        perimeter += Math.sqrt(Math.pow(lastPoint[0] - firstPoint[0], 2) +
+            Math.pow(lastPoint[1] - firstPoint[1], 2));
+    }
+    return perimeter;
+}
+export default calculatePerimeter;

package/dist/esm/utilities/contours/contourFinder.d.ts

@@ -0,0 +1,7 @@
+export declare function findContours(lines: any): any;
+export declare function findContoursFromReducedSet(lines: any): any;
+declare const _default: {
+    findContours: typeof findContours;
+    findContoursFromReducedSet: typeof findContoursFromReducedSet;
+};
+export default _default;

package/dist/esm/utilities/contours/contourFinder.js

@@ -0,0 +1,62 @@
+function findNextLink(line, lines, contourPoints) {
+    let index = -1;
+    lines.forEach((cell, i) => {
+        if (index >= 0) {
+            return;
+        }
+        if (cell.a == line.b) {
+            index = i;
+        }
+    });
+    if (index >= 0) {
+        const nextLine = lines[index];
+        lines.splice(index, 1);
+        contourPoints.push(nextLine.b);
+        if (contourPoints[0] == nextLine.b) {
+            return {
+                remainingLines: lines,
+                contourPoints,
+                type: 'CLOSED_PLANAR',
+            };
+        }
+        return findNextLink(nextLine, lines, contourPoints);
+    }
+    return {
+        remainingLines: lines,
+        contourPoints,
+        type: 'OPEN_PLANAR',
+    };
+}
+export function findContours(lines) {
+    if (lines.length == 0) {
+        return [];
+    }
+    const contourPoints = [];
+    const firstCell = lines.shift();
+    contourPoints.push(firstCell.a);
+    contourPoints.push(firstCell.b);
+    const result = findNextLink(firstCell, lines, contourPoints);
+    if (result.remainingLines.length == 0) {
+        return [
+            {
+                type: result.type,
+                contourPoints: result.contourPoints,
+            },
+        ];
+    }
+    else {
+        const extraContours = findContours(result.remainingLines);
+        extraContours.push({
+            type: result.type,
+            contourPoints: result.contourPoints,
+        });
+        return extraContours;
+    }
+}
+export function findContoursFromReducedSet(lines) {
+    return findContours(lines);
+}
+export default {
+    findContours,
+    findContoursFromReducedSet,
+};

package/dist/esm/utilities/contours/detectContourHoles.d.ts

@@ -0,0 +1,5 @@
+export declare function processContourHoles(contours: any, points: any, useXOR?: boolean): any;
+declare const _default: {
+    processContourHoles: typeof processContourHoles;
+};
+export default _default;

package/dist/esm/utilities/contours/detectContourHoles.js

@@ -0,0 +1,73 @@
+const getIsPointInsidePolygon = (point, vertices) => {
+    const x = point[0];
+    const y = point[1];
+    let inside = false;
+    for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
+        const xi = vertices[i][0], yi = vertices[i][1];
+        const xj = vertices[j][0], yj = vertices[j][1];
+        const intersect = yi > y != yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
+        }
+    }
+    return inside;
+};
+function checkEnclosed(outerContour, innerContour, points) {
+    const vertices = [];
+    outerContour.contourPoints.forEach((point) => {
+        vertices.push([points[point][0], points[point][1]]);
+    });
+    let pointsNotEnclosed = 0;
+    innerContour.contourPoints.forEach((point) => {
+        const result = getIsPointInsidePolygon([points[point][0], points[point][1]], vertices);
+        if (!result) {
+            pointsNotEnclosed++;
+        }
+    });
+    return pointsNotEnclosed === 0;
+}
+export function processContourHoles(contours, points, useXOR = true) {
+    const retContours = contours.filter((contour) => contour.type !== 'CLOSED_PLANAR');
+    const closedContours = contours.filter((contour) => contour.type === 'CLOSED_PLANAR');
+    const contourWithHoles = [];
+    let contourWithoutHoles = [];
+    closedContours.forEach((contour, index) => {
+        const holes = [];
+        closedContours.forEach((hContour, hIndex) => {
+            if (index != hIndex) {
+                if (checkEnclosed(contour, hContour, points)) {
+                    holes.push(hIndex);
+                }
+            }
+        });
+        if (holes.length > 0) {
+            contourWithHoles.push({
+                contour,
+                holes,
+            });
+        }
+        else {
+            contourWithoutHoles.push(index);
+        }
+    });
+    if (useXOR) {
+        contourWithHoles.forEach((contourHoleSet) => {
+            contourHoleSet.contour.type = 'CLOSEDPLANAR_XOR';
+            retContours.push(contourHoleSet.contour);
+            contourHoleSet.holes.forEach((holeIndex) => {
+                closedContours[holeIndex].type = 'CLOSEDPLANAR_XOR';
+                retContours.push(closedContours[holeIndex]);
+                contourWithoutHoles = contourWithoutHoles.filter((contourIndex) => {
+                    return contourIndex !== holeIndex;
+                });
+            });
+        });
+        contourWithoutHoles.forEach((contourIndex) => {
+            retContours.push(closedContours[contourIndex]);
+        });
+    }
+    else {
+    }
+    return retContours;
+}
+export default { processContourHoles };

package/dist/esm/utilities/contours/findHandlePolylineIndex.d.ts

@@ -0,0 +1,2 @@
+import { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+export default function findHandlePolylineIndex(annotation: ContourAnnotation, handleIndex: number): number;

package/dist/esm/utilities/contours/findHandlePolylineIndex.js

@@ -0,0 +1,31 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+const { isEqual } = csUtils;
+export default function findHandlePolylineIndex(annotation, handleIndex) {
+    const { polyline } = annotation.data.contour;
+    const { points } = annotation.data.handles;
+    const { length } = points;
+    if (handleIndex === length) {
+        return polyline.length;
+    }
+    if (handleIndex < 0) {
+        handleIndex = (handleIndex + length) % length;
+    }
+    if (handleIndex === 0) {
+        return 0;
+    }
+    const handle = points[handleIndex];
+    const index = polyline.findIndex((point) => isEqual(handle, point));
+    if (index !== -1) {
+        return index;
+    }
+    let closestDistance = Infinity;
+    return polyline.reduce((closestIndex, point, testIndex) => {
+        const distance = vec3.squaredDistance(point, handle);
+        if (distance < closestDistance) {
+            closestDistance = distance;
+            return testIndex;
+        }
+        return closestIndex;
+    }, -1);
+}

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.d.ts

@@ -0,0 +1,4 @@
+declare function generateContourSetsFromLabelmap({ segmentations }: {
+    segmentations: any;
+}): any[];
+export { generateContourSetsFromLabelmap };

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -0,0 +1,109 @@
+import { cache as cornerstoneCache } from '@cornerstonejs/core';
+import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { getDeduplicatedVTKPolyDataPoints } from '../contours';
+import { findContoursFromReducedSet } from './contourFinder';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+const { Labelmap } = SegmentationRepresentations;
+function generateContourSetsFromLabelmap({ segmentations }) {
+    const { representationData, segments = [0, 1] } = segmentations;
+    const { volumeId: segVolumeId } = representationData[Labelmap];
+    const vol = cornerstoneCache.getVolume(segVolumeId);
+    if (!vol) {
+        console.warn(`No volume found for ${segVolumeId}`);
+        return;
+    }
+    const numSlices = vol.dimensions[2];
+    const segData = vol.imageData.getPointData().getScalars().getData();
+    const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
+    for (let z = 0; z < numSlices; z++) {
+        for (let y = 0; y < vol.dimensions[1]; y++) {
+            const index = y * vol.dimensions[0] + z * pixelsPerSlice;
+            segData[index] = 0;
+            segData[index + vol.dimensions[0] - 1] = 0;
+        }
+    }
+    const ContourSets = [];
+    const { FrameOfReferenceUID } = vol.metadata;
+    const numSegments = segments.length;
+    for (let segIndex = 0; segIndex < numSegments; segIndex++) {
+        const segment = segments[segIndex];
+        if (!segment) {
+            continue;
+        }
+        const sliceContours = [];
+        const scalars = vtkDataArray.newInstance({
+            name: 'Scalars',
+            numberOfComponents: 1,
+            size: pixelsPerSlice * numSlices,
+            dataType: 'Uint8Array',
+        });
+        const { containedSegmentIndices } = segment;
+        for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+                continue;
+            }
+            const frameStart = sliceIndex * pixelsPerSlice;
+            try {
+                for (let i = 0; i < pixelsPerSlice; i++) {
+                    const value = segData[i + frameStart];
+                    if (value === segIndex || containedSegmentIndices?.has(value)) {
+                        scalars.setValue(i + frameStart, 1);
+                    }
+                    else {
+                        scalars.setValue(i, 0);
+                    }
+                }
+                const mSquares = vtkImageMarchingSquares.newInstance({
+                    slice: sliceIndex,
+                });
+                const imageDataCopy = vtkImageData.newInstance();
+                imageDataCopy.shallowCopy(vol.imageData);
+                imageDataCopy.getPointData().setScalars(scalars);
+                mSquares.setInputData(imageDataCopy);
+                const cValues = [1];
+                mSquares.setContourValues(cValues);
+                mSquares.setMergePoints(false);
+                const msOutput = mSquares.getOutputData();
+                const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
+                if (reducedSet.points?.length) {
+                    const contours = findContoursFromReducedSet(reducedSet.lines);
+                    sliceContours.push({
+                        contours,
+                        polyData: reducedSet,
+                        FrameNumber: sliceIndex + 1,
+                        sliceIndex,
+                        FrameOfReferenceUID,
+                    });
+                }
+            }
+            catch (e) {
+                console.warn(sliceIndex);
+                console.warn(e);
+            }
+        }
+        const metadata = {
+            FrameOfReferenceUID,
+        };
+        const ContourSet = {
+            label: segment.label,
+            color: segment.color,
+            metadata,
+            sliceContours,
+        };
+        ContourSets.push(ContourSet);
+    }
+    return ContourSets;
+}
+function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+    const startIdx = sliceIndex * pixelsPerSlice;
+    const endIdx = startIdx + pixelsPerSlice;
+    for (let i = startIdx; i < endIdx; i++) {
+        if (segData[i] === segIndex) {
+            return false;
+        }
+    }
+    return true;
+}
+export { generateContourSetsFromLabelmap };

package/dist/esm/utilities/contours/getContourHolesDataCanvas.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+export default function getContourHolesDataCanvas(annotation: Annotation, viewport: Types.IViewport): Types.Point2[][];

package/dist/esm/utilities/contours/getContourHolesDataCanvas.js

@@ -0,0 +1,14 @@
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+export default function getContourHolesDataCanvas(annotation, viewport) {
+    const worldHoleContours = getContourHolesDataWorld(annotation);
+    const canvasHoleContours = [];
+    worldHoleContours.forEach((worldHoleContour) => {
+        const numPoints = worldHoleContour.length;
+        const canvasHoleContour = new Array(numPoints);
+        for (let i = 0; i < numPoints; i++) {
+            canvasHoleContour[i] = viewport.worldToCanvas(worldHoleContour[i]);
+        }
+        canvasHoleContours.push(canvasHoleContour);
+    });
+    return canvasHoleContours;
+}

package/dist/esm/utilities/contours/getContourHolesDataWorld.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+export default function getContourHolesDataWorld(annotation: Annotation): Types.Point3[][];

package/dist/esm/utilities/contours/getContourHolesDataWorld.js

@@ -0,0 +1,5 @@
+import { getAnnotation } from '../../stateManagement';
+export default function getContourHolesDataWorld(annotation) {
+    const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
+    return childAnnotationUIDs.map((uid) => getAnnotation(uid).data.contour.polyline);
+}

package/dist/esm/utilities/contours/getDeduplicatedVTKPolyDataPoints.d.ts

@@ -0,0 +1,11 @@
+export declare function getDeduplicatedVTKPolyDataPoints(polyData: any, bypass?: boolean): {
+    points: any[];
+    lines: {
+        a: any;
+        b: any;
+    }[];
+};
+declare const _default: {
+    getDeduplicatedVTKPolyDataPoints: typeof getDeduplicatedVTKPolyDataPoints;
+};
+export default _default;

package/dist/esm/utilities/contours/getDeduplicatedVTKPolyDataPoints.js

@@ -0,0 +1,45 @@
+export function getDeduplicatedVTKPolyDataPoints(polyData, bypass = false) {
+    const points = polyData.getPoints();
+    const lines = polyData.getLines();
+    const pointsArray = new Array(points.getNumberOfPoints())
+        .fill(0)
+        .map((_, i) => points.getPoint(i).slice());
+    const linesArray = new Array(lines.getNumberOfCells()).fill(0).map((_, i) => {
+        const cell = lines.getCell(i * 3).slice();
+        return { a: cell[0], b: cell[1] };
+    });
+    if (bypass) {
+        return { points: pointsArray, lines: linesArray };
+    }
+    const newPoints = [];
+    for (const [i, pt] of pointsArray.entries()) {
+        const index = newPoints.findIndex((point) => point[0] === pt[0] && point[1] === pt[1] && point[2] === pt[2]);
+        if (index >= 0) {
+            linesArray.map((line) => {
+                if (line.a === i) {
+                    line.a = index;
+                }
+                if (line.b === i) {
+                    line.b = index;
+                }
+                return line;
+            });
+        }
+        else {
+            const newIndex = newPoints.length;
+            newPoints.push(pt);
+            linesArray.map((line) => {
+                if (line.a === i) {
+                    line.a = newIndex;
+                }
+                if (line.b === i) {
+                    line.b = newIndex;
+                }
+                return line;
+            });
+        }
+    }
+    const newLines = linesArray.filter((line) => line.a !== line.b);
+    return { points: newPoints, lines: newLines };
+}
+export default { getDeduplicatedVTKPolyDataPoints };

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

@@ -0,0 +1,14 @@
+import areCoplanarContours from './areCoplanarContours';
+import contourFinder from './contourFinder';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
+import detectContourHoles from './detectContourHoles';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
+import AnnotationToPointData from './AnnotationToPointData';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+import updateContourPolyline from './updateContourPolyline';
+import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
+import * as interpolation from './interpolation';
+import findHandlePolylineIndex from './findHandlePolylineIndex';
+import calculatePerimeter from './calculatePerimeter';
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

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

@@ -0,0 +1,14 @@
+import areCoplanarContours from './areCoplanarContours';
+import contourFinder from './contourFinder';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
+import detectContourHoles from './detectContourHoles';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
+import AnnotationToPointData from './AnnotationToPointData';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+import updateContourPolyline from './updateContourPolyline';
+import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
+import * as interpolation from './interpolation';
+import findHandlePolylineIndex from './findHandlePolylineIndex';
+import calculatePerimeter from './calculatePerimeter';
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

package/dist/esm/utilities/contours/interpolation/acceptAutogeneratedInterpolations.d.ts

@@ -0,0 +1,3 @@
+import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
+import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
+export default function acceptAutogeneratedInterpolations(annotationGroupSelector: AnnotationGroupSelector, selector: AcceptInterpolationSelector): void;

package/dist/esm/utilities/contours/interpolation/acceptAutogeneratedInterpolations.js

@@ -0,0 +1,4 @@
+import InterpolationManager from '../../segmentation/InterpolationManager/InterpolationManager';
+export default function acceptAutogeneratedInterpolations(annotationGroupSelector, selector) {
+    InterpolationManager.acceptAutoGenerated(annotationGroupSelector, selector);
+}

package/dist/esm/utilities/contours/interpolation/createPolylineToolData.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+export default function createPolylineToolData(polyline: any, handlePoints: any, referencedToolData: any): InterpolationROIAnnotation;

package/dist/esm/utilities/contours/interpolation/createPolylineToolData.js

@@ -0,0 +1,38 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+export default function createPolylineToolData(polyline, handlePoints, referencedToolData) {
+    const annotation = csUtils.deepMerge({
+        data: {},
+        metadata: {},
+    }, referencedToolData);
+    Object.assign(annotation, {
+        highlighted: false,
+        invalidated: true,
+        autoGenerated: true,
+        annotationUID: undefined,
+        cachedStats: {},
+        childAnnotationUIDs: [],
+        parentAnnotationUID: undefined,
+    });
+    Object.assign(annotation.data, {
+        handles: {
+            points: handlePoints.points || handlePoints || [],
+            interpolationSources: handlePoints.sources,
+            activeHandleIndex: null,
+            textBox: {
+                hasMoved: false,
+                worldPosition: [0, 0, 0],
+                worldBoundingBox: {
+                    topLeft: [0, 0, 0],
+                    topRight: [0, 0, 0],
+                    bottomLeft: [0, 0, 0],
+                    bottomRight: [0, 0, 0],
+                },
+            },
+        },
+        contour: {
+            ...referencedToolData.data.contour,
+            polyline,
+        },
+    });
+    return annotation;
+}

package/dist/esm/utilities/contours/interpolation/findAnnotationForInterpolation.d.ts

@@ -0,0 +1,7 @@
+import type { InterpolationViewportData, Annotation } from '../../../types';
+export type ContourPair = [number, number];
+declare function findAnnotationsForInterpolation(toolData: any, viewportData: InterpolationViewportData): {
+    interpolationData: Map<number, Annotation[]>;
+    interpolationList: any[];
+};
+export default findAnnotationsForInterpolation;