@cornerstonejs/tools 5.1.3 → 5.2.0

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import { StackViewport } from '@cornerstonejs/core';
-import type { Annotation } from '../types';
+import type { Annotation } from '../types/index.js';
 declare function annotationHydration(viewport: Types.IViewport, toolName: string, worldPoints: Types.Point3[], options?: {
     FrameOfReferenceUID?: string;
     annotationUID?: string;

package/dist/esm/utilities/annotationHydration.js

@@ -1,5 +1,5 @@
 import { utilities, BaseVolumeViewport, StackViewport, cache, metaData, } from '@cornerstonejs/core';
-import { addAnnotation } from '../stateManagement/annotation/annotationState';
+import { addAnnotation } from '../stateManagement/annotation/annotationState.js';
 import { vec3 } from 'gl-matrix';
 function annotationHydration(viewport, toolName, worldPoints, options) {
     const viewReference = viewport.getViewReference();

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

@@ -1,4 +1,4 @@
-import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis';
-import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld } from './getBoundingBoxAroundShape';
-import snapIndexBounds from './snapIndexBounds';
+import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis.js';
+import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld } from './getBoundingBoxAroundShape.js';
+import snapIndexBounds from './snapIndexBounds.js';
 export { extend2DBoundingBoxInViewAxis, getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, snapIndexBounds, getBoundingBoxAroundShapeIJK as getBoundingBoxAroundShape, };

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

@@ -1,4 +1,4 @@
-import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis';
-import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from './getBoundingBoxAroundShape';
-import snapIndexBounds from './snapIndexBounds';
+import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis.js';
+import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from './getBoundingBoxAroundShape.js';
+import snapIndexBounds from './snapIndexBounds.js';
 export { extend2DBoundingBoxInViewAxis, getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, snapIndexBounds, getBoundingBoxAroundShapeIJK as getBoundingBoxAroundShape, };

package/dist/esm/utilities/calibrateImageSpacing.js

@@ -1,5 +1,5 @@
 import { utilities, Enums } from '@cornerstonejs/core';
-import { viewportSupportsStackCalibration, viewportSupportsStackCompatibility, } from './viewportCapabilities';
+import { viewportSupportsStackCalibration, viewportSupportsStackCompatibility, } from './viewportCapabilities.js';
 const { calibratedPixelSpacingMetadataProvider } = utilities;
 export default function calibrateImageSpacing(imageId, renderingEngine, calibrationOrScale) {
     if (typeof calibrationOrScale === 'number') {

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

@@ -1,4 +1,4 @@
-import { playClip, stopClip } from './playClip';
-import Events from './events';
-import { getToolState, addToolState } from './state';
+import { playClip, stopClip } from './playClip.js';
+import Events from './events.js';
+import { getToolState, addToolState } from './state.js';
 export { playClip, stopClip, Events, getToolState, addToolState };

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

@@ -1,4 +1,4 @@
-import { playClip, stopClip } from './playClip';
-import Events from './events';
-import { getToolState, addToolState } from './state';
+import { playClip, stopClip } from './playClip.js';
+import Events from './events.js';
+import { getToolState, addToolState } from './state.js';
 export { playClip, stopClip, Events, getToolState, addToolState };

package/dist/esm/utilities/cine/playClip.d.ts

@@ -1,4 +1,4 @@
-import type { CINETypes } from '../../types';
+import type { CINETypes } from '../../types/index.js';
 type StopClipOptions = {
     stopDynamicCine: boolean;
     viewportId?: string;

package/dist/esm/utilities/cine/playClip.js

@@ -1,7 +1,7 @@
 import { glMatrix, vec3 } from 'gl-matrix';
 import { utilities as csUtils, getEnabledElement, StackViewport, VideoViewport, VolumeViewport, cache, BaseVolumeViewport, Enums, } from '@cornerstonejs/core';
-import CINE_EVENTS from './events';
-import { addToolState, getToolState, getToolStateByViewportId } from './state';
+import CINE_EVENTS from './events.js';
+import { addToolState, getToolState, getToolStateByViewportId } from './state.js';
 const { ViewportStatus } = Enums;
 const { triggerEvent } = csUtils;
 const debounced = true;

package/dist/esm/utilities/cine/state.d.ts

@@ -1,4 +1,4 @@
-import type { CINETypes } from '../../types';
+import type { CINETypes } from '../../types/index.js';
 declare function addToolState(element: HTMLDivElement, data: CINETypes.ToolData): void;
 declare function getToolState(element: HTMLDivElement): CINETypes.ToolData | undefined;
 declare function getToolStateByViewportId(viewportId: string): CINETypes.ToolData | undefined;

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

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

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

@@ -1,5 +1,5 @@
-import { setAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { setAnnotationLocked } from '../../stateManagement/annotation/annotationLocking.js';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation.js';
 export function addContourSegmentationAnnotation(annotation) {
     if (annotation.parentAnnotationUID) {
         return;

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import type { PolylineInfoWorld } from './polylineInfoTypes';
+import type { PolylineInfoWorld } from './polylineInfoTypes.js';
 export default function addPolylinesToSegmentation(viewport: Types.IViewport, annotationUIDsMap: Map<number, Set<string>>, segmentationId: string, polylinesInfo: PolylineInfoWorld[], segmentIndex: number): Map<number, Set<string>>;

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

@@ -1,39 +1,66 @@
 import { utilities } from '@cornerstonejs/core';
-import { addAnnotation } from '../../stateManagement';
+import { addAnnotation } from '../../stateManagement/index.js';
+import { addChildAnnotation } from '../../stateManagement/annotation/annotationState.js';
+import updateContourPolyline from '../contours/updateContourPolyline.js';
+import { ContourWindingDirection } from '../../types/ContourAnnotation.js';
 const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
 export default function addPolylinesToSegmentation(viewport, annotationUIDsMap, segmentationId, polylinesInfo, segmentIndex) {
-    polylinesInfo.forEach(({ polyline, viewReference }) => {
+    polylinesInfo.forEach(({ polyline, viewReference, holePolylines }) => {
         if (polyline.length < 3) {
             return;
         }
-        const contourSegmentationAnnotation = {
-            annotationUID: utilities.uuidv4(),
-            data: {
-                contour: {
-                    closed: true,
-                    polyline,
-                },
-                segmentation: {
-                    segmentationId,
-                    segmentIndex,
-                },
-                handles: {},
-            },
-            handles: {},
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
-                ...viewReference,
-            },
-        };
-        addAnnotation(contourSegmentationAnnotation, viewport.element);
+        const parentAnnotation = createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference);
+        addAnnotation(parentAnnotation, viewport.element);
+        const parentPolylineCanvas = polyline.map((point) => viewport.worldToCanvas(point));
+        updateContourPolyline(parentAnnotation, {
+            points: parentPolylineCanvas,
+            closed: true,
+            targetWindingDirection: ContourWindingDirection.Clockwise,
+        }, viewport);
         const currentSet = annotationUIDsMap?.get(segmentIndex) || new Set();
-        currentSet.add(contourSegmentationAnnotation.annotationUID);
+        currentSet.add(parentAnnotation.annotationUID);
         annotationUIDsMap.set(segmentIndex, currentSet);
+        holePolylines?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const holeAnnotation = createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference);
+            addAnnotation(holeAnnotation, viewport.element);
+            addChildAnnotation(parentAnnotation, holeAnnotation);
+            const holePolylineCanvas = holePolyline.map((point) => viewport.worldToCanvas(point));
+            updateContourPolyline(holeAnnotation, {
+                points: holePolylineCanvas,
+                closed: true,
+                targetWindingDirection: ContourWindingDirection.CounterClockwise,
+            }, viewport);
+        });
     });
     return annotationUIDsMap;
 }
+function createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference) {
+    return {
+        annotationUID: utilities.uuidv4(),
+        data: {
+            contour: {
+                closed: true,
+                polyline: [],
+            },
+            segmentation: {
+                segmentationId,
+                segmentIndex,
+            },
+            handles: {},
+            cachedStats: {},
+        },
+        handles: {},
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
+            ...viewReference,
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
+export declare function addContourStroke(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation): void;
+export declare function removeContourStroke(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation): void;

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

@@ -0,0 +1,102 @@
+import { ContourWindingDirection } from '../../types/ContourAnnotation.js';
+import { applyBoolean, BooleanOp, splitSelfIntersections, } from './clipperBooleanOps.js';
+import { unifyWeaklyConnectedPolygons } from './bridgeWeaklyConnected.js';
+import { convertContourPolylineToCanvasSpace, createNewAnnotationFromPolyline, getContourHolesData, updateViewportsForAnnotations, } from './sharedOperations.js';
+import { getAllAnnotations } from '../../stateManagement/annotation/annotationState.js';
+import { addAnnotation, addChildAnnotation, removeAnnotation, } from '../../stateManagement/annotation/annotationState.js';
+import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation.js';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state.js';
+import areSameSegment from './areSameSegment.js';
+import isContourSegmentationAnnotation from './isContourSegmentationAnnotation.js';
+import { hasToolByName } from '../../store/addTool.js';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+export function addContourStroke(viewport, sourceAnnotation) {
+    applyStroke(viewport, sourceAnnotation, BooleanOp.Union);
+}
+export function removeContourStroke(viewport, sourceAnnotation) {
+    applyStroke(viewport, sourceAnnotation, BooleanOp.Difference);
+}
+function applyStroke(viewport, sourceAnnotation, op) {
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered. Cannot apply stroke.`);
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
+    if (sourcePolyline.length < 3) {
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const targets = collectSamePlaneSegmentTargets(viewport, sourceAnnotation);
+    const subjects = targets.map((t) => {
+        const outer = convertContourPolylineToCanvasSpace(t.data.contour.polyline, viewport);
+        const holes = getContourHolesData(viewport, t).map((h) => h.polyline);
+        return { outer, holes: holes.length ? holes : undefined };
+    });
+    const clips = splitSelfIntersections(sourcePolyline);
+    if (clips.length === 0) {
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const booleanResult = applyBoolean(subjects, clips, op);
+    const resultPolygons = op === BooleanOp.Union
+        ? unifyWeaklyConnectedPolygons(booleanResult)
+        : booleanResult;
+    const toRemove = [sourceAnnotation];
+    for (const t of targets) {
+        toRemove.push(t);
+        for (const h of getContourHolesData(viewport, t)) {
+            toRemove.push(h.annotation);
+        }
+    }
+    for (const annotation of toRemove) {
+        removeAnnotationCompletely(annotation);
+    }
+    const template = targets[0] ?? sourceAnnotation;
+    const { element } = viewport;
+    for (const polygon of resultPolygons) {
+        if (polygon.outer.length < 3) {
+            continue;
+        }
+        const parent = createNewAnnotationFromPolyline(viewport, template, polygon.outer, ContourWindingDirection.Clockwise);
+        addAnnotation(parent, element);
+        addContourSegmentationAnnotation(parent);
+        polygon.holes?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const hole = createNewAnnotationFromPolyline(viewport, template, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
+        triggerAnnotationModified(parent, element);
+    }
+    updateViewportsForAnnotations(viewport, toRemove);
+}
+function collectSamePlaneSegmentTargets(viewport, sourceAnnotation) {
+    const sourceUID = sourceAnnotation.annotationUID;
+    return getAllAnnotations().filter((candidate) => {
+        if (!candidate.annotationUID || candidate.annotationUID === sourceUID) {
+            return false;
+        }
+        if (!isContourSegmentationAnnotation(candidate)) {
+            return false;
+        }
+        if (!areSameSegment(candidate, sourceAnnotation)) {
+            return false;
+        }
+        if (!viewport.isReferenceViewable(candidate.metadata)) {
+            return false;
+        }
+        if (candidate.parentAnnotationUID) {
+            return false;
+        }
+        return true;
+    });
+}
+function removeAnnotationCompletely(annotation) {
+    removeAnnotation(annotation.annotationUID);
+    removeContourSegmentationAnnotation(annotation);
+}

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

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

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import { type PolygonWithHoles } from './clipperBooleanOps.js';
+export declare function unifyWeaklyConnectedPolygons(polygons: PolygonWithHoles[]): PolygonWithHoles[];
+export declare function bridgeSelfIntersectingPolyline(line: Types.Point2[]): Types.Point2[];

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

@@ -0,0 +1,126 @@
+import * as math from '../math/index.js';
+import { splitSelfIntersections, } from './clipperBooleanOps.js';
+const TOUCH_EPS = 1e-2;
+const TOUCH_EPS_SQ = TOUCH_EPS * TOUCH_EPS;
+function dist2(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    return dx * dx + dy * dy;
+}
+function boxesWithinEps(a, b) {
+    return (a.minX <= b.maxX + TOUCH_EPS &&
+        b.minX <= a.maxX + TOUCH_EPS &&
+        a.minY <= b.maxY + TOUCH_EPS &&
+        b.minY <= a.maxY + TOUCH_EPS);
+}
+function ringsTouch(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            if (dist2(a[i], b[j]) <= TOUCH_EPS_SQ) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function spliceTwoRings(a, b) {
+    const bb = math.polyline.getWindingDirection(b) !==
+        math.polyline.getWindingDirection(a)
+        ? [...b].reverse()
+        : b;
+    let best = Infinity;
+    let ai = 0;
+    let bj = 0;
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < bb.length; j++) {
+            const d = dist2(a[i], bb[j]);
+            if (d < best) {
+                best = d;
+                ai = i;
+                bj = j;
+            }
+        }
+    }
+    const loop = [...bb.slice(bj), ...bb.slice(0, bj)];
+    return [...a.slice(0, ai + 1), ...loop, loop[0], ...a.slice(ai + 1)];
+}
+function groupTouchingOuters(outers) {
+    const n = outers.length;
+    const parent = Array.from({ length: n }, (_, i) => i);
+    const find = (x) => {
+        let root = x;
+        while (parent[root] !== root) {
+            root = parent[root];
+        }
+        while (parent[x] !== root) {
+            const next = parent[x];
+            parent[x] = root;
+            x = next;
+        }
+        return root;
+    };
+    const union = (x, y) => {
+        parent[find(x)] = find(y);
+    };
+    const boxes = outers.map((o) => math.polyline.getAABB(o));
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (boxesWithinEps(boxes[i], boxes[j]) &&
+                ringsTouch(outers[i], outers[j])) {
+                union(i, j);
+            }
+        }
+    }
+    const groups = new Map();
+    for (let i = 0; i < n; i++) {
+        const root = find(i);
+        const group = groups.get(root);
+        if (group) {
+            group.push(i);
+        }
+        else {
+            groups.set(root, [i]);
+        }
+    }
+    return [...groups.values()];
+}
+export function unifyWeaklyConnectedPolygons(polygons) {
+    if (polygons.length < 2) {
+        return polygons;
+    }
+    const outers = polygons.map((p) => p.outer);
+    const groups = groupTouchingOuters(outers);
+    if (groups.length === polygons.length) {
+        return polygons;
+    }
+    return groups.map((group) => {
+        if (group.length === 1) {
+            return polygons[group[0]];
+        }
+        let outer = polygons[group[0]].outer;
+        for (let k = 1; k < group.length; k++) {
+            outer = spliceTwoRings(outer, polygons[group[k]].outer);
+        }
+        const holes = group.flatMap((idx) => polygons[idx].holes ?? []);
+        return holes.length ? { outer, holes } : { outer };
+    });
+}
+export function bridgeSelfIntersectingPolyline(line) {
+    const polygons = splitSelfIntersections(line);
+    if (polygons.length === 0) {
+        return line;
+    }
+    if (polygons.length === 1 && !polygons[0].holes?.length) {
+        return line;
+    }
+    const unified = unifyWeaklyConnectedPolygons(polygons);
+    const main = unified.reduce((largest, candidate) => math.polyline.getArea(candidate.outer) >
+        math.polyline.getArea(largest.outer)
+        ? candidate
+        : largest);
+    let outer = main.outer;
+    for (const hole of main.holes ?? []) {
+        outer = spliceTwoRings(outer, hole);
+    }
+    return outer;
+}

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

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+export type PolygonWithHoles = {
+    outer: Types.Point2[];
+    holes?: Types.Point2[][];
+};
+export declare enum BooleanOp {
+    Union = 0,
+    Difference = 1,
+    Intersection = 2,
+    Xor = 3
+}
+export declare function applyBoolean(subjects: PolygonWithHoles[], clips: PolygonWithHoles[], op: BooleanOp): PolygonWithHoles[];
+export declare function splitSelfIntersections(polyline: Types.Point2[]): PolygonWithHoles[];

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

@@ -0,0 +1,126 @@
+import { Clipper, ClipType, FillRule, PolyTreeD, } from 'clipper2-ts';
+const PRECISION = 4;
+export var BooleanOp;
+(function (BooleanOp) {
+    BooleanOp[BooleanOp["Union"] = 0] = "Union";
+    BooleanOp[BooleanOp["Difference"] = 1] = "Difference";
+    BooleanOp[BooleanOp["Intersection"] = 2] = "Intersection";
+    BooleanOp[BooleanOp["Xor"] = 3] = "Xor";
+})(BooleanOp || (BooleanOp = {}));
+const opToClipType = {
+    [BooleanOp.Union]: ClipType.Union,
+    [BooleanOp.Difference]: ClipType.Difference,
+    [BooleanOp.Intersection]: ClipType.Intersection,
+    [BooleanOp.Xor]: ClipType.Xor,
+};
+function point2ToPathD(polyline) {
+    const len = polyline.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = { x: polyline[i][0], y: polyline[i][1] };
+    }
+    return out;
+}
+function pathDToPoint2(path) {
+    const len = path.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = [path[i].x, path[i].y];
+    }
+    return out;
+}
+function polygonsToPathsD(polygons) {
+    const paths = [];
+    for (const p of polygons) {
+        if (p.outer.length >= 3) {
+            paths.push(point2ToPathD(p.outer));
+        }
+        if (p.holes) {
+            for (const hole of p.holes) {
+                if (hole.length >= 3) {
+                    paths.push(point2ToPathD(hole));
+                }
+            }
+        }
+    }
+    return paths;
+}
+function polyTreeToPolygons(tree) {
+    const out = [];
+    collectOuters(tree, out);
+    return out;
+}
+function collectOuters(node, out) {
+    for (let i = 0; i < node.count; i++) {
+        const child = node.child(i);
+        if (child.isHole) {
+            collectOuters(child, out);
+            continue;
+        }
+        const outerPoly = child.poly;
+        if (!outerPoly || outerPoly.length < 3) {
+            continue;
+        }
+        const polygon = { outer: pathDToPoint2(outerPoly) };
+        const holes = [];
+        for (let j = 0; j < child.count; j++) {
+            const grand = child.child(j);
+            if (grand.isHole) {
+                const holePoly = grand.poly;
+                if (holePoly && holePoly.length >= 3) {
+                    holes.push(pathDToPoint2(holePoly));
+                }
+                collectOuters(grand, out);
+            }
+        }
+        if (holes.length > 0) {
+            polygon.holes = holes;
+        }
+        out.push(polygon);
+    }
+}
+function clonePolygons(polygons) {
+    return polygons.map((p) => ({
+        outer: p.outer.map((pt) => [pt[0], pt[1]]),
+        holes: p.holes?.map((h) => h.map((pt) => [pt[0], pt[1]])),
+    }));
+}
+export function applyBoolean(subjects, clips, op) {
+    if (subjects.length === 0) {
+        if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+            return clonePolygons(clips);
+        }
+        return [];
+    }
+    if (clips.length === 0) {
+        if (op === BooleanOp.Intersection) {
+            return [];
+        }
+        return clonePolygons(subjects);
+    }
+    const subjectPaths = polygonsToPathsD(subjects);
+    const clipPaths = polygonsToPathsD(clips);
+    if (subjectPaths.length === 0) {
+        if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+            return clonePolygons(clips);
+        }
+        return [];
+    }
+    if (clipPaths.length === 0) {
+        if (op === BooleanOp.Intersection) {
+            return [];
+        }
+        return clonePolygons(subjects);
+    }
+    const tree = new PolyTreeD();
+    Clipper.booleanOpDWithPolyTree(opToClipType[op], subjectPaths, clipPaths, tree, FillRule.EvenOdd, PRECISION);
+    return polyTreeToPolygons(tree);
+}
+export function splitSelfIntersections(polyline) {
+    if (polyline.length < 3) {
+        return [];
+    }
+    const tree = new PolyTreeD();
+    Clipper.booleanOpDWithPolyTree(ClipType.Union, [point2ToPathD(polyline)], null, tree, FillRule.EvenOdd, PRECISION);
+    return polyTreeToPolygons(tree);
+}

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation.js';
 export declare function contourSegmentationOperation(sourceAnnotationOrUID: ContourSegmentationAnnotation | string, targetAnnotationOrUID: ContourSegmentationAnnotation | string, viewport?: Types.IViewport, contourHoleProcessingEnabled?: boolean): Promise<void>;

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

@@ -1,6 +1,6 @@
-import { getAnnotation } from '../../stateManagement/annotation/annotationState';
-import getViewportsForAnnotation from '../getViewportsForAnnotation';
-import { convertContourPolylineToCanvasSpace, checkIntersection, createPolylineHole, combinePolylines, } from './sharedOperations';
+import { getAnnotation } from '../../stateManagement/annotation/annotationState.js';
+import getViewportsForAnnotation from '../getViewportsForAnnotation.js';
+import { convertContourPolylineToCanvasSpace, checkIntersection, createPolylineHole, combinePolylines, } from './sharedOperations.js';
 export async function contourSegmentationOperation(sourceAnnotationOrUID, targetAnnotationOrUID, viewport, contourHoleProcessingEnabled = true) {
     const sourceAnnotation = typeof sourceAnnotationOrUID === 'string'
         ? getAnnotation(sourceAnnotationOrUID)

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

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

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

@@ -1,8 +1,8 @@
 import { utilities } from '@cornerstonejs/core';
-import { addAnnotation, removeAnnotation } from '../../stateManagement';
-import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
-import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
-import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import { addAnnotation, removeAnnotation } from '../../stateManagement/index.js';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation.js';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state.js';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export default function convertContourSegmentationAnnotation(annotation) {
     const { polyline } = annotation.data?.contour || {};

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

@@ -1,3 +1,3 @@
-import type { ContourSegmentationAnnotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
 export declare function copyAnnotation(annotation: ContourSegmentationAnnotation, segmentationId: string, segmentIndex: number): ContourSegmentationAnnotation;
 export declare function copyContourSegment(segmentationId: string, segmentIndex: number, targetSegmentationId: string, targetSegmentIndex: number): void;

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

@@ -1,8 +1,8 @@
 import { utilities } from '@cornerstonejs/core';
-import { addAnnotation, getAnnotation } from '../../stateManagement';
-import { getViewportAssociatedToSegmentation } from '../../stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation';
-import { getToolGroupForViewport } from '../../store/ToolGroupManager';
-import { getAnnotationsUIDMapFromSegmentation } from '../../stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation';
+import { addAnnotation, getAnnotation } from '../../stateManagement/index.js';
+import { getViewportAssociatedToSegmentation } from '../../stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation.js';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager/index.js';
+import { getAnnotationsUIDMapFromSegmentation } from '../../stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.js';
 export function copyAnnotation(annotation, segmentationId, segmentIndex) {
     const newAnnotation = {
         annotationUID: utilities.uuidv4(),