@cornerstonejs/tools 5.1.3 → 5.2.0

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

@@ -1,57 +1,10 @@
-import * as math from '../math';
-import { checkIntersection, convertContourPolylineToCanvasSpace, } from './sharedOperations';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
-import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { convertContourPolylineToCanvasSpace } from './sharedOperations.js';
+import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation.js';
+import { runBooleanOpByView } from './polylineSetOps.js';
+import { BooleanOp } from './clipperBooleanOps.js';
+import { getChildAnnotations } from '../../stateManagement/annotation/annotationState.js';
 export function unifyPolylineSets(polylinesSetA, polylinesSetB) {
-    const result = [];
-    const processedFromA = new Set();
-    const processedFromB = new Set();
-    for (let i = 0; i < polylinesSetA.length; i++) {
-        if (processedFromA.has(i)) {
-            continue;
-        }
-        const polylineA = polylinesSetA[i];
-        let merged = false;
-        for (let j = 0; j < polylinesSetB.length; j++) {
-            if (processedFromB.has(j)) {
-                continue;
-            }
-            const polylineB = polylinesSetB[j];
-            if (!areViewReferencesEqual(polylineA.viewReference, polylineB.viewReference)) {
-                continue;
-            }
-            if (arePolylinesIdentical(polylineA.polyline, polylineB.polyline)) {
-                result.push(polylineA);
-                processedFromA.add(i);
-                processedFromB.add(j);
-                merged = true;
-                break;
-            }
-            const intersection = checkIntersection(polylineA.polyline, polylineB.polyline);
-            if (intersection.hasIntersection && !intersection.isContourHole) {
-                const mergedPolyline = math.polyline.mergePolylines(polylineA.polyline, polylineB.polyline);
-                result.push({
-                    polyline: mergedPolyline,
-                    viewReference: polylineA.viewReference,
-                });
-                processedFromA.add(i);
-                processedFromB.add(j);
-                merged = true;
-                break;
-            }
-        }
-        if (!merged) {
-            result.push(polylineA);
-            processedFromA.add(i);
-        }
-    }
-    for (let j = 0; j < polylinesSetB.length; j++) {
-        if (!processedFromB.has(j)) {
-            result.push(polylinesSetB[j]);
-        }
-    }
-    return result;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Union);
 }
 export function unifyMultiplePolylineSets(polylineSets) {
     if (polylineSets.length === 0) {
@@ -60,20 +13,20 @@ export function unifyMultiplePolylineSets(polylineSets) {
     if (polylineSets.length === 1) {
         return [...polylineSets[0]];
     }
-    let result = [...polylineSets[0]];
+    let result = polylineSets[0];
     for (let i = 1; i < polylineSets.length; i++) {
         result = unifyPolylineSets(result, polylineSets[i]);
     }
     return result;
 }
 export function unifyAnnotationPolylines(annotationsSetA, annotationsSetB, viewport) {
-    const polylinesSetA = annotationsSetA.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    const polylinesSetB = annotationsSetB.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    return unifyPolylineSets(polylinesSetA, polylinesSetB);
+    const toInfo = (annotation) => {
+        const holePolylines = getChildAnnotations(annotation).map((child) => convertContourPolylineToCanvasSpace(child.data.contour.polyline, viewport));
+        return {
+            polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
+            viewReference: getViewReferenceFromAnnotation(annotation),
+            ...(holePolylines.length ? { holePolylines } : {}),
+        };
+    };
+    return unifyPolylineSets(annotationsSetA.map(toInfo), annotationsSetB.map(toInfo));
 }

package/dist/esm/utilities/contourSegmentation/polylineXor.d.ts

@@ -1,2 +1,2 @@
-import type { PolylineInfoCanvas } from './polylineInfoTypes';
+import type { PolylineInfoCanvas } from './polylineInfoTypes.js';
 export declare function xorPolylinesSets(polylinesSetA: PolylineInfoCanvas[], polylinesSetB: PolylineInfoCanvas[]): PolylineInfoCanvas[];

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

@@ -1,41 +1,5 @@
-import { cleanupPolylines } from './sharedOperations';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
-import { subtractPolylineSets } from './polylineSubtract';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps.js';
+import { BooleanOp } from './clipperBooleanOps.js';
 export function xorPolylinesSets(polylinesSetA, polylinesSetB) {
-    if (!polylinesSetA.length && !polylinesSetB.length) {
-        return [];
-    }
-    if (!polylinesSetA.length) {
-        return polylinesSetB;
-    }
-    if (!polylinesSetB.length) {
-        return polylinesSetA;
-    }
-    if (polylinesSetA.length === polylinesSetB.length) {
-        let allIdentical = true;
-        for (let i = 0; i < polylinesSetA.length; i++) {
-            let foundMatch = false;
-            for (let j = 0; j < polylinesSetB.length; j++) {
-                if (!areViewReferencesEqual(polylinesSetA[i].viewReference, polylinesSetB[j].viewReference)) {
-                    continue;
-                }
-                if (arePolylinesIdentical(polylinesSetA[i].polyline, polylinesSetB[j].polyline)) {
-                    foundMatch = true;
-                    break;
-                }
-            }
-            if (!foundMatch) {
-                allIdentical = false;
-                break;
-            }
-        }
-        if (allIdentical) {
-            return [];
-        }
-    }
-    const aMinusB = subtractPolylineSets(polylinesSetA, polylinesSetB);
-    const bMinusA = subtractPolylineSets(polylinesSetB, polylinesSetA);
-    const xorResult = [...aMinusB, ...bMinusA];
-    return xorResult;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Xor);
 }

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.d.ts

@@ -1,2 +1,2 @@
-import type { ContourSegmentationAnnotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
 export declare function removeContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): void;

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

@@ -1,4 +1,4 @@
-import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation.js';
 export function removeContourSegmentationAnnotation(annotation) {
     if (!annotation.data.segmentation) {
         throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');

package/dist/esm/utilities/contourSegmentation/sharedOperations.d.ts

@@ -1,10 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation.js';
+import { ContourWindingDirection } from '../../types/ContourAnnotation.js';
 export declare function convertContourPolylineToCanvasSpace(polyline: Types.Point3[], viewport: Types.IViewport): Types.Point2[];
 export declare function convertContourPolylineToWorld(polyline: Types.Point2[], viewport: Types.IViewport): Types.Point3[];
 export declare function checkIntersection(sourcePolyline: Types.Point2[], targetPolyline: Types.Point2[]): {
     hasIntersection: boolean;
     isContourHole: boolean;
+    isTargetInsideSource: boolean;
 };
 export declare function getContourHolesData(viewport: Types.IViewport, annotation: ContourSegmentationAnnotation): Array<{
     annotation: ContourSegmentationAnnotation;
@@ -12,7 +14,7 @@ export declare function getContourHolesData(viewport: Types.IViewport, annotatio
 }>;
 export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;
 export declare function combinePolylines(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, targetPolyline: Types.Point2[], sourceAnnotation: ContourSegmentationAnnotation, sourcePolyline: Types.Point2[]): void;
-export declare function createNewAnnotationFromPolyline(viewport: Types.IViewport, templateAnnotation: ContourSegmentationAnnotation, polyline: Types.Point2[]): ContourSegmentationAnnotation;
+export declare function createNewAnnotationFromPolyline(viewport: Types.IViewport, templateAnnotation: ContourSegmentationAnnotation, polyline: Types.Point2[], windingDirection?: ContourWindingDirection): ContourSegmentationAnnotation;
 export declare function updateViewportsForAnnotations(viewport: Types.IViewport, annotations: ContourSegmentationAnnotation[]): void;
 export declare function removeDuplicatePoints(polyline: Types.Point2[]): Types.Point2[];
 export declare function cleanupPolylines(polylines: Types.Point2[][]): Types.Point2[][];

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

@@ -1,14 +1,15 @@
 import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
-import { ContourWindingDirection } from '../../types/ContourAnnotation';
-import * as math from '../math';
-import updateContourPolyline from '../contours/updateContourPolyline';
-import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../stateManagement/annotation/annotationState';
-import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
-import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
-import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
-import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
-import { getViewportIdsWithToolToRender } from '../viewportFilters';
-import { hasToolByName } from '../../store/addTool';
+import { ContourWindingDirection } from '../../types/ContourAnnotation.js';
+import * as math from '../math/index.js';
+import updateContourPolyline from '../contours/updateContourPolyline.js';
+import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, } from '../../stateManagement/annotation/annotationState.js';
+import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation.js';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state.js';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds.js';
+import { getViewportIdsWithToolToRender } from '../viewportFilters/index.js';
+import { hasToolByName } from '../../store/addTool.js';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps.js';
 const TOLERANCE = 1e-10;
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export function convertContourPolylineToCanvasSpace(polyline, viewport) {
@@ -32,13 +33,20 @@ export function checkIntersection(sourcePolyline, targetPolyline) {
     const targetAABB = math.polyline.getAABB(targetPolyline);
     const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
     if (!aabbIntersect) {
-        return { hasIntersection: false, isContourHole: false };
+        return {
+            hasIntersection: false,
+            isContourHole: false,
+            isTargetInsideSource: false,
+        };
     }
     const lineSegmentsIntersect = math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
     const isContourHole = !lineSegmentsIntersect &&
         math.polyline.containsPoints(targetPolyline, sourcePolyline);
-    const hasIntersection = lineSegmentsIntersect || isContourHole;
-    return { hasIntersection, isContourHole };
+    const isTargetInsideSource = !lineSegmentsIntersect &&
+        !isContourHole &&
+        math.polyline.containsPoints(sourcePolyline, targetPolyline);
+    const hasIntersection = lineSegmentsIntersect || isContourHole || isTargetInsideSource;
+    return { hasIntersection, isContourHole, isTargetInsideSource };
 }
 export function getContourHolesData(viewport, annotation) {
     return getChildAnnotations(annotation).map((holeAnnotation) => {
@@ -71,63 +79,47 @@ export function combinePolylines(viewport, targetAnnotation, targetPolyline, sou
     const sourceStartPoint = sourcePolyline[0];
     const mergePolylines = math.polyline.containsPoint(targetPolyline, sourceStartPoint);
     const contourHolesData = getContourHolesData(viewport, targetAnnotation);
-    const unassignedContourHolesSet = new Set(contourHolesData);
-    const reassignedContourHolesMap = new Map();
-    const assignHoleToPolyline = (parentPolyline, holeData) => {
-        let holes = reassignedContourHolesMap.get(parentPolyline);
-        if (!holes) {
-            holes = [];
-            reassignedContourHolesMap.set(parentPolyline, holes);
-        }
-        holes.push(holeData);
-        unassignedContourHolesSet.delete(holeData);
-    };
-    const newPolylines = [];
-    if (mergePolylines) {
-        const mergedPolyline = math.polyline.mergePolylines(targetPolyline, sourcePolyline);
-        newPolylines.push(mergedPolyline);
-        Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => assignHoleToPolyline(mergedPolyline, holeData));
-    }
-    else {
-        const subtractedPolylines = math.polyline.subtractPolylines(targetPolyline, sourcePolyline);
-        subtractedPolylines.forEach((newPolyline) => {
-            newPolylines.push(newPolyline);
-            Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => {
-                const containsHole = math.polyline.containsPoints(newPolyline, holeData.polyline);
-                if (containsHole) {
-                    assignHoleToPolyline(newPolyline, holeData);
-                }
-            });
-        });
-    }
-    Array.from(reassignedContourHolesMap.values()).forEach((contourHolesDataArray) => contourHolesDataArray.forEach((contourHoleData) => clearParentAnnotation(contourHoleData.annotation)));
+    const subjects = [
+        {
+            outer: targetPolyline,
+            holes: contourHolesData.length
+                ? contourHolesData.map((h) => h.polyline)
+                : undefined,
+        },
+    ];
+    const clips = [{ outer: sourcePolyline }];
+    const resultPolygons = applyBoolean(subjects, clips, mergePolylines ? BooleanOp.Union : BooleanOp.Difference);
     const { element } = viewport;
-    const { metadata, data } = targetAnnotation;
-    const { handles, segmentation } = data;
-    const { textBox } = handles;
-    removeAnnotation(sourceAnnotation.annotationUID);
-    removeAnnotation(targetAnnotation.annotationUID);
-    removeContourSegmentationAnnotation(sourceAnnotation);
-    removeContourSegmentationAnnotation(targetAnnotation);
-    const newAnnotations = [];
-    for (let i = 0; i < newPolylines.length; i++) {
-        const polyline = newPolylines[i];
-        if (!polyline || polyline.length < 3) {
-            console.warn('Skipping creation of new annotation due to invalid polyline:', polyline);
-            continue;
+    const annotationsToRemove = [
+        sourceAnnotation,
+        targetAnnotation,
+        ...contourHolesData.map((h) => h.annotation),
+    ];
+    annotationsToRemove.forEach((annotation) => {
+        removeAnnotation(annotation.annotationUID);
+        removeContourSegmentationAnnotation(annotation);
+    });
+    resultPolygons.forEach((polygon) => {
+        if (polygon.outer.length < 3) {
+            return;
         }
-        const newAnnotation = createNewAnnotationFromPolyline(viewport, targetAnnotation, polyline);
-        addAnnotation(newAnnotation, element);
-        addContourSegmentationAnnotation(newAnnotation);
-        triggerAnnotationModified(newAnnotation, viewport.element);
-        newAnnotations.push(newAnnotation);
-        reassignedContourHolesMap
-            .get(polyline)
-            ?.forEach((holeData) => addChildAnnotation(newAnnotation, holeData.annotation));
-    }
+        const parent = createNewAnnotationFromPolyline(viewport, targetAnnotation, polygon.outer, ContourWindingDirection.Clockwise);
+        addAnnotation(parent, element);
+        addContourSegmentationAnnotation(parent);
+        triggerAnnotationModified(parent, element);
+        polygon.holes?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const hole = createNewAnnotationFromPolyline(viewport, targetAnnotation, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
+    });
     updateViewportsForAnnotations(viewport, [targetAnnotation, sourceAnnotation]);
 }
-export function createNewAnnotationFromPolyline(viewport, templateAnnotation, polyline) {
+export function createNewAnnotationFromPolyline(viewport, templateAnnotation, polyline, windingDirection = ContourWindingDirection.Clockwise) {
     const startPointWorld = viewport.canvasToWorld(polyline[0]);
     const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
     const newAnnotation = {
@@ -165,7 +157,7 @@ export function createNewAnnotationFromPolyline(viewport, templateAnnotation, po
     updateContourPolyline(newAnnotation, {
         points: polyline,
         closed: true,
-        targetWindingDirection: ContourWindingDirection.Clockwise,
+        targetWindingDirection: windingDirection,
     }, viewport);
     return newAnnotation;
 }

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

@@ -1,4 +1,4 @@
-import RectangleROIStartEndThreshold from './RectangleROIStartEndThreshold';
+import RectangleROIStartEndThreshold from './RectangleROIStartEndThreshold.js';
 function validateAnnotation(annotation) {
     if (!annotation?.data) {
         throw new Error('Tool data is empty');

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

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

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

@@ -1,6 +1,6 @@
-import getSignedArea from '../math/polyline/getSignedArea';
-import containsPoints from '../math/polyline/containsPoints';
-import isClosed from '../math/polyline/isClosed';
+import getSignedArea from '../math/polyline/getSignedArea.js';
+import containsPoints from '../math/polyline/containsPoints.js';
+import isClosed from '../math/polyline/isClosed.js';
 function isPolygonInsidePolygon(inner, outer) {
     return containsPoints(outer, inner);
 }

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

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

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

@@ -1,5 +1,5 @@
-import isClosed from '../math/polyline/isClosed';
-import { getSignedArea } from '../math/polyline';
+import isClosed from '../math/polyline/isClosed.js';
+import { getSignedArea } from '../math/polyline/index.js';
 export default function findIslands(polylines, threshold) {
     if (!polylines || polylines.length === 0) {
         return [];

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

@@ -1,9 +1,9 @@
 import { cache as cornerstoneCache, getWebWorkerManager, cache, utilities, } from '@cornerstonejs/core';
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import { WorkerTypes } from '../../enums';
-import { registerComputeWorker } from '../registerComputeWorker';
-import { triggerWorkerProgress } from '../segmentation/utilsForWorker';
-import getOrCreateSegmentationVolume from '../segmentation/getOrCreateSegmentationVolume';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations.js';
+import { WorkerTypes } from '../../enums/index.js';
+import { registerComputeWorker } from '../registerComputeWorker.js';
+import { triggerWorkerProgress } from '../segmentation/utilsForWorker.js';
+import getOrCreateSegmentationVolume from '../segmentation/getOrCreateSegmentationVolume.js';
 const { Labelmap } = SegmentationRepresentations;
 async function generateContourSetsFromLabelmap({ segmentations }) {
     registerComputeWorker();

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

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

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

@@ -1,4 +1,4 @@
-import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataWorld from './getContourHolesDataWorld.js';
 export default function getContourHolesDataCanvas(annotation, viewport) {
     const worldHoleContours = getContourHolesDataWorld(annotation);
     const canvasHoleContours = [];

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

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

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

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

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

@@ -1,14 +1,14 @@
-import areCoplanarContours from './areCoplanarContours';
-import contourFinder from './contourFinder';
-import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
-import detectContourHoles from './detectContourHoles';
-import findContourHoles from './findContourHoles';
-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 findHandlePolylineIndex from './findHandlePolylineIndex';
-import findIslands from './findIslands';
+import areCoplanarContours from './areCoplanarContours.js';
+import contourFinder from './contourFinder.js';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints.js';
+import detectContourHoles from './detectContourHoles.js';
+import findContourHoles from './findContourHoles.js';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap.js';
+import AnnotationToPointData from './AnnotationToPointData.js';
+import getContourHolesDataWorld from './getContourHolesDataWorld.js';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas.js';
+import updateContourPolyline from './updateContourPolyline.js';
+import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations.js';
+import findHandlePolylineIndex from './findHandlePolylineIndex.js';
+import findIslands from './findIslands.js';
 export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, findIslands, };

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

@@ -1,14 +1,14 @@
-import areCoplanarContours from './areCoplanarContours';
-import contourFinder from './contourFinder';
-import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
-import detectContourHoles from './detectContourHoles';
-import findContourHoles from './findContourHoles';
-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 findHandlePolylineIndex from './findHandlePolylineIndex';
-import findIslands from './findIslands';
+import areCoplanarContours from './areCoplanarContours.js';
+import contourFinder from './contourFinder.js';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints.js';
+import detectContourHoles from './detectContourHoles.js';
+import findContourHoles from './findContourHoles.js';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap.js';
+import AnnotationToPointData from './AnnotationToPointData.js';
+import getContourHolesDataWorld from './getContourHolesDataWorld.js';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas.js';
+import updateContourPolyline from './updateContourPolyline.js';
+import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations.js';
+import findHandlePolylineIndex from './findHandlePolylineIndex.js';
+import findIslands from './findIslands.js';
 export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, findContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, findIslands, };

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import getInterpolationData from './getInterpolationData';
+import getInterpolationData from './getInterpolationData.js';
 function findAnnotationsForInterpolation(toolData, viewportData) {
     const interpolationData = getInterpolationData(viewportData, [
         {

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

@@ -1,4 +1,4 @@
-import type { InterpolationViewportData, Annotation } from '../../../types';
+import type { InterpolationViewportData, Annotation } from '../../../types/index.js';
 export type FilterParam = {
     parentKey?: (annotation: Annotation) => unknown;
     key: string;

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

@@ -1,4 +1,4 @@
-import { getAnnotations } from '../../../stateManagement/annotation/annotationState';
+import { getAnnotations } from '../../../stateManagement/annotation/annotationState.js';
 const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
 export default function getInterpolationData(viewportData, filterParams = []) {
     const { viewport, sliceData, annotation } = viewportData;

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

@@ -1,4 +1,4 @@
-import type { InterpolationViewportData } from '../../../types';
-import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
-import type { FilterParam } from './getInterpolationData';
+import type { InterpolationViewportData } from '../../../types/index.js';
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes.js';
+import type { FilterParam } from './getInterpolationData.js';
 export default function getInterpolationDataCollection(viewportData: InterpolationViewportData, filterParams: FilterParam[]): InterpolationROIAnnotation[];

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

@@ -1,4 +1,4 @@
-import getInterpolationData from './getInterpolationData';
+import getInterpolationData from './getInterpolationData.js';
 export default function getInterpolationDataCollection(viewportData, filterParams) {
     const imageAnnotations = getInterpolationData(viewportData, filterParams);
     const interpolatedDataCollection = [];

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import type { InterpolationViewportData } from '../../../types/InterpolationTypes';
+import type { InterpolationViewportData } from '../../../types/InterpolationTypes.js';
 export type PointsXYZI = Types.PointsXYZ & {
     I?: boolean[];
     kIndex?: number;

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

@@ -1,12 +1,12 @@
 import { eventTarget, triggerEvent, utilities } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-import createPolylineToolData from './createPolylineToolData';
-import findAnnotationsForInterpolation from './findAnnotationForInterpolation';
-import EventTypes from '../../../enums/Events';
-import * as annotationState from '../../../stateManagement/annotation';
-import selectHandles from './selectHandles';
-import updateChildInterpolationUID from './updateChildInterpolationUID';
-import { createPolylineHole } from '../../contourSegmentation';
+import createPolylineToolData from './createPolylineToolData.js';
+import findAnnotationsForInterpolation from './findAnnotationForInterpolation.js';
+import EventTypes from '../../../enums/Events.js';
+import * as annotationState from '../../../stateManagement/annotation/index.js';
+import selectHandles from './selectHandles.js';
+import updateChildInterpolationUID from './updateChildInterpolationUID.js';
+import { createPolylineHole } from '../../contourSegmentation/index.js';
 const { PointsManager } = utilities;
 const dP = 0.2;
 function interpolate(viewportData) {

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

@@ -1,4 +1,4 @@
-import type { PointsArray3 } from './interpolate';
+import type { PointsArray3 } from './interpolate.js';
 export interface SelectHandlesOptions {
     handleCount?: number;
     isOpenUShapeContour?: boolean;

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

@@ -1,2 +1,2 @@
-import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes.js';
 export default function updateChildInterpolationUID(annotation: InterpolationROIAnnotation): string;

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

@@ -1,4 +1,4 @@
-import * as annotationState from '../../../stateManagement/annotation';
+import * as annotationState from '../../../stateManagement/annotation/index.js';
 export default function updateChildInterpolationUID(annotation) {
     const { parentAnnotationUID, annotationUID } = annotation;
     if (!parentAnnotationUID) {

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

@@ -1,4 +1,4 @@
-import { getSignedArea } from '../math/polyline';
+import { getSignedArea } from '../math/polyline/index.js';
 export default function reverseIfAntiClockwise(points, ...otherListsToReverse) {
     const signedArea = getSignedArea(points);
     if (signedArea < 0) {