@cornerstonejs/tools 3.19.1 → 3.19.3

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.d.ts

@@ -1,5 +1,2 @@
-import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
 import type { AnnotationCompletedEventType } from '../../../types/EventTypes';
 export default function contourSegmentationCompletedListener(evt: AnnotationCompletedEventType): Promise<void>;
-export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.js

@@ -1,15 +1,10 @@
-import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
 import getViewportsForAnnotation from '../../../utilities/getViewportsForAnnotation';
-import * as math from '../../../utilities/math';
-import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
-import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
-import { addAnnotation, removeAnnotation, getAllAnnotations, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../../stateManagement/annotation/annotationState';
-import { ContourWindingDirection } from '../../../types/ContourAnnotation';
-import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
-import updateContourPolyline from '../../../utilities/contours/updateContourPolyline';
-import { addContourSegmentationAnnotation, areSameSegment, isContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
+import { getAllAnnotations } from '../../../stateManagement/annotation/annotationState';
+import { areSameSegment, isContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
 import { getToolGroupForViewport } from '../../../store/ToolGroupManager';
-import { hasTool, hasToolByName } from '../../../store/addTool';
+import { findAllIntersectingContours } from '../../../utilities/contourSegmentation/getIntersectingAnnotations';
+import { processMultipleIntersections } from '../../../utilities/contourSegmentation/mergeMultipleAnnotations';
+import { convertContourPolylineToCanvasSpace, createPolylineHole, combinePolylines, } from '../../../utilities/contourSegmentation/sharedOperations';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export default async function contourSegmentationCompletedListener(evt) {
     const sourceAnnotation = evt.detail
@@ -23,11 +18,15 @@ export default async function contourSegmentationCompletedListener(evt) {
         return;
     }
     const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
-    const targetAnnotationInfo = findIntersectingContour(viewport, sourcePolyline, contourSegmentationAnnotations);
-    if (!targetAnnotationInfo) {
+    const intersectingContours = findAllIntersectingContours(viewport, sourcePolyline, contourSegmentationAnnotations);
+    if (!intersectingContours.length) {
         return;
     }
-    const { targetAnnotation, targetPolyline, isContourHole } = targetAnnotationInfo;
+    if (intersectingContours.length > 1) {
+        processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline, intersectingContours);
+        return;
+    }
+    const { targetAnnotation, targetPolyline, isContourHole } = intersectingContours[0];
     if (isContourHole) {
         const { contourHoleProcessingEnabled = false } = evt.detail;
         if (!contourHoleProcessingEnabled) {
@@ -43,11 +42,14 @@ function isFreehandContourSegToolRegisteredForViewport(viewport, silent = false)
     const toolName = 'PlanarFreehandContourSegmentationTool';
     const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
     let errorMessage;
-    if (!toolGroup.hasTool(toolName)) {
+    if (!toolGroup) {
+        errorMessage = `ToolGroup not found for viewport ${viewport.id}`;
+    }
+    else if (!toolGroup.hasTool(toolName)) {
         errorMessage = `Tool ${toolName} not added to ${toolGroup.id} toolGroup`;
     }
     else if (!toolGroup.getToolOptions(toolName)) {
-        errorMessage = `Tool ${toolName} must be in active/passive state`;
+        errorMessage = `Tool ${toolName} must be in active/passive state in ${toolGroup.id} toolGroup`;
     }
     if (errorMessage && !silent) {
         console.warn(errorMessage);
@@ -59,14 +61,6 @@ function getViewport(annotation) {
     const viewportWithToolRegistered = viewports.find((viewport) => isFreehandContourSegToolRegisteredForViewport(viewport, true));
     return viewportWithToolRegistered ?? viewports[0];
 }
-function convertContourPolylineToCanvasSpace(polyline, viewport) {
-    const numPoints = polyline.length;
-    const projectedPolyline = new Array(numPoints);
-    for (let i = 0; i < numPoints; i++) {
-        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
-    }
-    return projectedPolyline;
-}
 function getValidContourSegmentationAnnotations(viewport, sourceAnnotation) {
     const { annotationUID: sourceAnnotationUID } = sourceAnnotation;
     const allAnnotations = getAllAnnotations();
@@ -76,158 +70,3 @@ function getValidContourSegmentationAnnotations(viewport, sourceAnnotation) {
         areSameSegment(targetAnnotation, sourceAnnotation) &&
         viewport.isReferenceViewable(targetAnnotation.metadata));
 }
-function findIntersectingContour(viewport, sourcePolyline, contourSegmentationAnnotations) {
-    const sourceAABB = math.polyline.getAABB(sourcePolyline);
-    for (let i = 0; i < contourSegmentationAnnotations.length; i++) {
-        const targetAnnotation = contourSegmentationAnnotations[i];
-        const targetPolyline = convertContourPolylineToCanvasSpace(targetAnnotation.data.contour.polyline, viewport);
-        const targetAABB = math.polyline.getAABB(targetPolyline);
-        const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
-        const lineSegmentsIntersect = aabbIntersect &&
-            math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
-        const isContourHole = aabbIntersect &&
-            !lineSegmentsIntersect &&
-            math.polyline.containsPoints(targetPolyline, sourcePolyline);
-        if (lineSegmentsIntersect || isContourHole) {
-            return { targetAnnotation, targetPolyline, isContourHole };
-        }
-    }
-}
-export function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
-    const { windingDirection: targetWindingDirection } = targetAnnotation.data.contour;
-    const { windingDirection: holeWindingDirection } = holeAnnotation.data.contour;
-    addChildAnnotation(targetAnnotation, holeAnnotation);
-    removeContourSegmentationAnnotation(holeAnnotation);
-    const { contour: holeContour } = holeAnnotation.data;
-    const holePolyline = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
-    updateContourPolyline(holeAnnotation, {
-        points: holePolyline,
-        closed: holeContour.closed,
-    }, viewport);
-    const { element } = viewport;
-    const updatedToolNames = new Set([
-        DEFAULT_CONTOUR_SEG_TOOL_NAME,
-        targetAnnotation.metadata.toolName,
-        holeAnnotation.metadata.toolName,
-    ]);
-    for (const toolName of updatedToolNames.values()) {
-        const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
-        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
-    }
-}
-function getContourHolesData(viewport, annotation) {
-    return getChildAnnotations(annotation).map((holeAnnotation) => {
-        const polyline = convertContourPolylineToCanvasSpace(holeAnnotation.data.contour.polyline, viewport);
-        return { annotation: holeAnnotation, polyline };
-    });
-}
-function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline) {
-    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
-        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered in cornerstone`);
-        return;
-    }
-    if (!isFreehandContourSegToolRegisteredForViewport(viewport)) {
-        return;
-    }
-    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);
-                    unassignedContourHolesSet.delete(holeData);
-                }
-            });
-        });
-    }
-    Array.from(reassignedContourHolesMap.values()).forEach((contourHolesDataArray) => contourHolesDataArray.forEach((contourHoleData) => clearParentAnnotation(contourHoleData.annotation)));
-    const { element } = viewport;
-    const enabledElement = getEnabledElement(element);
-    const { metadata, data } = targetAnnotation;
-    const { handles, segmentation } = data;
-    const { textBox } = handles;
-    removeAnnotation(sourceAnnotation.annotationUID);
-    removeAnnotation(targetAnnotation.annotationUID);
-    for (let i = 0; i < newPolylines.length; i++) {
-        const polyline = newPolylines[i];
-        const startPoint = viewport.canvasToWorld(polyline[0]);
-        const endPoint = viewport.canvasToWorld(polyline[polyline.length - 1]);
-        const newAnnotation = {
-            metadata: {
-                ...metadata,
-                toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
-                originalToolName: metadata.originalToolName || metadata.toolName,
-            },
-            data: {
-                cachedStats: {},
-                handles: {
-                    points: [startPoint, endPoint],
-                    textBox: textBox ? { ...textBox } : undefined,
-                },
-                contour: {
-                    polyline: [],
-                    closed: true,
-                },
-                spline: targetAnnotation.data.spline,
-                segmentation: {
-                    ...segmentation,
-                },
-            },
-            annotationUID: csUtils.uuidv4(),
-            highlighted: true,
-            invalidated: true,
-            isLocked: false,
-            isVisible: undefined,
-            interpolationUID: targetAnnotation.interpolationUID,
-            interpolationCompleted: targetAnnotation.interpolationCompleted,
-        };
-        updateContourPolyline(newAnnotation, {
-            points: polyline,
-            closed: true,
-            targetWindingDirection: ContourWindingDirection.Clockwise,
-        }, viewport);
-        addAnnotation(newAnnotation, element);
-        addContourSegmentationAnnotation(newAnnotation);
-        triggerAnnotationModified(newAnnotation, viewport.element);
-        reassignedContourHolesMap
-            .get(polyline)
-            ?.forEach((holeData) => addChildAnnotation(newAnnotation, holeData.annotation));
-    }
-    updateViewports(enabledElement, targetAnnotation, sourceAnnotation);
-}
-function updateViewports(enabledElement, targetAnnotation, sourceAnnotation) {
-    const { viewport } = enabledElement;
-    const { element } = viewport;
-    const updatedTtoolNames = new Set([
-        DEFAULT_CONTOUR_SEG_TOOL_NAME,
-        targetAnnotation.metadata.toolName,
-        sourceAnnotation.metadata.toolName,
-    ]);
-    for (const toolName of updatedTtoolNames.values()) {
-        const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
-        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
-    }
-    return new Promise((resolve) => window.requestAnimationFrame(resolve));
-}

package/dist/esm/tools/segmentation/LabelmapEditWithContour.js

@@ -60,6 +60,9 @@ class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool
                 data: {},
             });
         }
+        else {
+            LabelMapEditWithContourTool.viewportIdsChecked.push(viewportId);
+        }
         return true;
     }
     onViewportAddedToToolGroup(evt) {

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function addPolylinesToSegmentation(viewport: Types.IViewport, segmentationId: string, polylines: Types.Point3[][], segmentIndex: number): Map<number, Set<string>>;

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

@@ -0,0 +1,40 @@
+import { utilities } from '@cornerstonejs/core';
+import { addAnnotation } from '../../stateManagement';
+const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+export default function addPolylinesToSegmentation(viewport, segmentationId, polylines, segmentIndex) {
+    const annotationUIDsMap = new Map();
+    polylines.forEach((polyline) => {
+        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,
+                ...viewport.getViewReference(),
+            },
+        };
+        addAnnotation(contourSegmentationAnnotation, viewport.element);
+        const currentSet = annotationUIDsMap?.get(segmentIndex) || new Set();
+        currentSet.add(contourSegmentationAnnotation.annotationUID);
+        annotationUIDsMap.set(segmentIndex, currentSet);
+    });
+    return annotationUIDsMap;
+}

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

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

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

@@ -0,0 +1,41 @@
+import { getAnnotation } from '../../stateManagement/annotation/annotationState';
+import getViewportsForAnnotation from '../getViewportsForAnnotation';
+import { convertContourPolylineToCanvasSpace, checkIntersection, createPolylineHole, combinePolylines, } from './sharedOperations';
+export async function contourSegmentationOperation(sourceAnnotationOrUID, targetAnnotationOrUID, viewport, contourHoleProcessingEnabled = true) {
+    const sourceAnnotation = typeof sourceAnnotationOrUID === 'string'
+        ? getAnnotation(sourceAnnotationOrUID)
+        : sourceAnnotationOrUID;
+    const targetAnnotation = typeof targetAnnotationOrUID === 'string'
+        ? getAnnotation(targetAnnotationOrUID)
+        : targetAnnotationOrUID;
+    if (!sourceAnnotation || !targetAnnotation) {
+        throw new Error('Both source and target annotations must be valid');
+    }
+    if (!viewport) {
+        viewport = getViewportFromAnnotation(sourceAnnotation);
+    }
+    const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
+    const targetPolyline = convertContourPolylineToCanvasSpace(targetAnnotation.data.contour.polyline, viewport);
+    const intersectionInfo = checkIntersection(sourcePolyline, targetPolyline);
+    if (!intersectionInfo.hasIntersection) {
+        console.warn('No intersection found between the two annotations');
+        return;
+    }
+    if (intersectionInfo.isContourHole) {
+        if (!contourHoleProcessingEnabled) {
+            console.warn('Hole processing is disabled');
+            return;
+        }
+        createPolylineHole(viewport, targetAnnotation, sourceAnnotation);
+    }
+    else {
+        combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline);
+    }
+}
+function getViewportFromAnnotation(annotation) {
+    const viewports = getViewportsForAnnotation(annotation);
+    if (!viewports.length) {
+        throw new Error('No viewport found for the annotation');
+    }
+    return viewports[0];
+}

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

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+declare function findAllIntersectingContours(viewport: Types.IViewport, sourcePolyline: Types.Point2[], contourSegmentationAnnotations: ContourSegmentationAnnotation[]): Array<{
+    targetAnnotation: ContourSegmentationAnnotation;
+    targetPolyline: Types.Point2[];
+    isContourHole: boolean;
+}>;
+export { findAllIntersectingContours };

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

@@ -0,0 +1,34 @@
+import * as math from '../math';
+function findAllIntersectingContours(viewport, sourcePolyline, contourSegmentationAnnotations) {
+    const intersectingContours = [];
+    const sourceAABB = math.polyline.getAABB(sourcePolyline);
+    for (let i = 0; i < contourSegmentationAnnotations.length; i++) {
+        const targetAnnotation = contourSegmentationAnnotations[i];
+        const targetPolyline = convertContourPolylineToCanvasSpace(targetAnnotation.data.contour.polyline, viewport);
+        const targetAABB = math.polyline.getAABB(targetPolyline);
+        const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
+        if (!aabbIntersect) {
+            continue;
+        }
+        const lineSegmentsIntersect = math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
+        const isContourHole = !lineSegmentsIntersect &&
+            math.polyline.containsPoints(targetPolyline, sourcePolyline);
+        if (lineSegmentsIntersect || isContourHole) {
+            intersectingContours.push({
+                targetAnnotation,
+                targetPolyline,
+                isContourHole,
+            });
+        }
+    }
+    return intersectingContours;
+}
+function convertContourPolylineToCanvasSpace(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+    }
+    return projectedPolyline;
+}
+export { findAllIntersectingContours };

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

@@ -1,4 +1,11 @@
-export { default as areSameSegment } from './areSameSegment';
+import areSameSegment from './areSameSegment';
+import { addition, subtraction } from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
+export { findAllIntersectingContours } from './getIntersectingAnnotations';
+export { processMultipleIntersections } from './mergeMultipleAnnotations';
+export { contourSegmentationOperation } from './contourSegmentationOperation';
+export * from './sharedOperations';
+export { addition, subtraction, areSameSegment };
+export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';

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

@@ -1,4 +1,11 @@
-export { default as areSameSegment } from './areSameSegment';
+import areSameSegment from './areSameSegment';
+import { addition, subtraction } from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
+export { findAllIntersectingContours } from './getIntersectingAnnotations';
+export { processMultipleIntersections } from './mergeMultipleAnnotations';
+export { contourSegmentationOperation } from './contourSegmentationOperation';
+export * from './sharedOperations';
+export { addition, subtraction, areSameSegment };
+export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';

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

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Segmentation } from '../../types';
+export declare function addition(viewport: Types.IViewport, segmentation: Segmentation, segmentIndex1: number, segmentIndex2: number, { name, segmentIndex, color }: {
+    name: any;
+    segmentIndex: any;
+    color: any;
+}): void;
+export declare function subtraction(viewport: Types.IViewport, segmentation: Segmentation, segmentIndex1: number, segmentIndex2: number, { name, segmentIndex, color }: {
+    name: any;
+    segmentIndex: any;
+    color: any;
+}): void;

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

@@ -0,0 +1,75 @@
+import { getAnnotation } from '../../stateManagement';
+import { convertContourPolylineToCanvasSpace, convertContourPolylineToWorld, } from './sharedOperations';
+import { subtractPolylineSets, unifyPolylineSets } from './unifyPolylineSets';
+import addPolylinesToSegmentation from './addPolylinesToSegmentation';
+function getPolylines(contourRepresentationData, segmentIndex) {
+    const polylines = [];
+    const { annotationUIDsMap } = contourRepresentationData;
+    const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+    for (const annotationUID of annotationUIDs) {
+        const annotation = getAnnotation(annotationUID);
+        const { polyline } = annotation.data
+            .contour;
+        polylines.push(polyline);
+    }
+    return polylines;
+}
+function extractPolylines(viewport, segmentation, segmentIndex1, segmentIndex2) {
+    if (!segmentation) {
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        .Contour;
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    if (!annotationUIDsMap.get(segmentIndex1)) {
+        return;
+    }
+    if (!annotationUIDsMap.get(segmentIndex2)) {
+        return;
+    }
+    const polyLines1 = getPolylines(contourRepresentationData, segmentIndex1);
+    const polyLines2 = getPolylines(contourRepresentationData, segmentIndex2);
+    const polyLinesCanvas1 = polyLines1.map((polyline) => convertContourPolylineToCanvasSpace(polyline, viewport));
+    const polyLinesCanvas2 = polyLines2.map((polyline) => convertContourPolylineToCanvasSpace(polyline, viewport));
+    return { polyLinesCanvas1, polyLinesCanvas2 };
+}
+export function addition(viewport, segmentation, segmentIndex1, segmentIndex2, { name, segmentIndex, color }) {
+    const { polyLinesCanvas1, polyLinesCanvas2 } = extractPolylines(viewport, segmentation, segmentIndex1, segmentIndex2) ||
+        {};
+    if (!polyLinesCanvas1 || polyLinesCanvas2) {
+        return;
+    }
+    const polylinesMerged = unifyPolylineSets(polyLinesCanvas1, polyLinesCanvas2);
+    const polyLinesWorld = polylinesMerged.map((polyline) => convertContourPolylineToWorld(polyline, viewport));
+    const annotationUIDsMapNew = addPolylinesToSegmentation(viewport, segmentation.segmentationId, polyLinesWorld, segmentIndex);
+    const contourRepresentationData = segmentation.representationData
+        .Contour;
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    annotationUIDsMap.set(segmentIndex, annotationUIDsMapNew.get(segmentIndex));
+}
+export function subtraction(viewport, segmentation, segmentIndex1, segmentIndex2, { name, segmentIndex, color }) {
+    const { polyLinesCanvas1, polyLinesCanvas2 } = extractPolylines(viewport, segmentation, segmentIndex1, segmentIndex2) ||
+        {};
+    if (!polyLinesCanvas1 || polyLinesCanvas2) {
+        return;
+    }
+    const polylinesMerged = subtractPolylineSets(polyLinesCanvas1, polyLinesCanvas2);
+    const polyLinesWorld = polylinesMerged.map((polyline) => convertContourPolylineToWorld(polyline, viewport));
+    const annotationUIDsMapNew = addPolylinesToSegmentation(viewport, segmentation.segmentationId, polyLinesWorld, segmentIndex);
+    const contourRepresentationData = segmentation.representationData
+        .Contour;
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    annotationUIDsMap.set(segmentIndex, annotationUIDsMapNew.get(segmentIndex));
+}

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

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+declare function processMultipleIntersections(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation, sourcePolyline: Types.Point2[], intersectingContours: Array<{
+    targetAnnotation: ContourSegmentationAnnotation;
+    targetPolyline: Types.Point2[];
+    isContourHole: boolean;
+}>): void;
+export { processMultipleIntersections };

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

@@ -0,0 +1,175 @@
+import { utilities as csUtils, getEnabledElement } 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, hasTool } from '../../store/addTool';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+function processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline, intersectingContours) {
+    const holeOperations = intersectingContours.filter((item) => item.isContourHole);
+    const mergeOperations = intersectingContours.filter((item) => !item.isContourHole);
+    if (holeOperations.length > 0) {
+        const primaryHoleTarget = holeOperations[0];
+        createPolylineHole(viewport, primaryHoleTarget.targetAnnotation, sourceAnnotation);
+        updateViewportsForAnnotations(viewport, [
+            sourceAnnotation,
+            primaryHoleTarget.targetAnnotation,
+        ]);
+        return;
+    }
+    if (mergeOperations.length === 0) {
+        return;
+    }
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered in cornerstone. Cannot process multiple intersections.`);
+        return;
+    }
+    processSequentialIntersections(viewport, sourceAnnotation, sourcePolyline, mergeOperations);
+}
+function processSequentialIntersections(viewport, sourceAnnotation, sourcePolyline, mergeOperations) {
+    const { element } = viewport;
+    const allAnnotationsToRemove = [sourceAnnotation];
+    const allResultPolylines = [];
+    const allHoles = [];
+    mergeOperations.forEach(({ targetAnnotation }) => {
+        const holes = getContourHolesData(viewport, targetAnnotation);
+        allHoles.push(...holes);
+        allAnnotationsToRemove.push(targetAnnotation);
+    });
+    const sourceStartPoint = sourcePolyline[0];
+    const shouldMerge = mergeOperations.some(({ targetPolyline }) => math.polyline.containsPoint(targetPolyline, sourceStartPoint));
+    if (shouldMerge) {
+        let resultPolyline = sourcePolyline;
+        mergeOperations.forEach(({ targetPolyline }) => {
+            resultPolyline = math.polyline.mergePolylines(resultPolyline, targetPolyline);
+        });
+        allResultPolylines.push(resultPolyline);
+    }
+    else {
+        mergeOperations.forEach(({ targetPolyline }) => {
+            const subtractedPolylines = math.polyline.subtractPolylines(targetPolyline, sourcePolyline);
+            allResultPolylines.push(...subtractedPolylines);
+        });
+    }
+    allAnnotationsToRemove.forEach((annotation) => {
+        removeAnnotation(annotation.annotationUID);
+        removeContourSegmentationAnnotation(annotation);
+    });
+    allHoles.forEach((holeData) => clearParentAnnotation(holeData.annotation));
+    const baseAnnotation = mergeOperations[0].targetAnnotation;
+    const newAnnotations = [];
+    allResultPolylines.forEach((polyline) => {
+        if (!polyline || polyline.length < 3) {
+            console.warn('Skipping creation of new annotation due to invalid polyline:', polyline);
+            return;
+        }
+        const newAnnotation = createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline);
+        addAnnotation(newAnnotation, element);
+        addContourSegmentationAnnotation(newAnnotation);
+        triggerAnnotationModified(newAnnotation, viewport.element);
+        newAnnotations.push(newAnnotation);
+    });
+    reassignHolesToNewAnnotations(viewport, allHoles, newAnnotations);
+    updateViewportsForAnnotations(viewport, allAnnotationsToRemove);
+}
+function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline) {
+    const startPointWorld = viewport.canvasToWorld(polyline[0]);
+    const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
+    const newAnnotation = {
+        metadata: {
+            ...baseAnnotation.metadata,
+            toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
+            originalToolName: baseAnnotation.metadata.originalToolName ||
+                baseAnnotation.metadata.toolName,
+        },
+        data: {
+            cachedStats: {},
+            handles: {
+                points: [startPointWorld, endPointWorld],
+                textBox: baseAnnotation.data.handles.textBox
+                    ? { ...baseAnnotation.data.handles.textBox }
+                    : undefined,
+            },
+            contour: {
+                polyline: [],
+                closed: true,
+            },
+            spline: baseAnnotation.data.spline,
+            segmentation: {
+                ...baseAnnotation.data.segmentation,
+            },
+        },
+        annotationUID: csUtils.uuidv4(),
+        highlighted: true,
+        invalidated: true,
+        isLocked: false,
+        isVisible: undefined,
+        interpolationUID: baseAnnotation.interpolationUID,
+        interpolationCompleted: baseAnnotation.interpolationCompleted,
+    };
+    updateContourPolyline(newAnnotation, {
+        points: polyline,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+    }, viewport);
+    return newAnnotation;
+}
+function reassignHolesToNewAnnotations(viewport, holes, newAnnotations) {
+    holes.forEach((holeData) => {
+        const parentAnnotation = newAnnotations.find((annotation) => {
+            const parentPolyline = convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport);
+            return math.polyline.containsPoints(parentPolyline, holeData.polyline);
+        });
+        if (parentAnnotation) {
+            addChildAnnotation(parentAnnotation, holeData.annotation);
+        }
+    });
+}
+function getContourHolesData(viewport, annotation) {
+    return getChildAnnotations(annotation).map((holeAnnotation) => {
+        const contourHoleAnnotation = holeAnnotation;
+        const polyline = convertContourPolylineToCanvasSpace(contourHoleAnnotation.data.contour.polyline, viewport);
+        return { annotation: contourHoleAnnotation, polyline };
+    });
+}
+function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
+    addChildAnnotation(targetAnnotation, holeAnnotation);
+    removeContourSegmentationAnnotation(holeAnnotation);
+    const { contour: holeContour } = holeAnnotation.data;
+    const holePolylineCanvas = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
+    updateContourPolyline(holeAnnotation, {
+        points: holePolylineCanvas,
+        closed: holeContour.closed,
+        targetWindingDirection: targetAnnotation.data.contour.windingDirection ===
+            ContourWindingDirection.Clockwise
+            ? ContourWindingDirection.CounterClockwise
+            : ContourWindingDirection.Clockwise,
+    }, viewport);
+}
+function convertContourPolylineToCanvasSpace(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+    }
+    return projectedPolyline;
+}
+function updateViewportsForAnnotations(viewport, annotations) {
+    const { element } = viewport;
+    const updatedToolNames = new Set([DEFAULT_CONTOUR_SEG_TOOL_NAME]);
+    annotations.forEach((annotation) => {
+        updatedToolNames.add(annotation.metadata.toolName);
+    });
+    for (const toolName of updatedToolNames.values()) {
+        if (hasToolByName(toolName)) {
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        }
+    }
+}
+export { processMultipleIntersections };

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

@@ -0,0 +1,16 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+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;
+};
+export declare function getContourHolesData(viewport: Types.IViewport, annotation: ContourSegmentationAnnotation): Array<{
+    annotation: ContourSegmentationAnnotation;
+    polyline: Types.Point2[];
+}>;
+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 updateViewportsForAnnotations(viewport: Types.IViewport, annotations: ContourSegmentationAnnotation[]): void;

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

@@ -0,0 +1,183 @@
+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';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+export function convertContourPolylineToCanvasSpace(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+    }
+    return projectedPolyline;
+}
+export function convertContourPolylineToWorld(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.canvasToWorld(polyline[i]);
+    }
+    return projectedPolyline;
+}
+export function checkIntersection(sourcePolyline, targetPolyline) {
+    const sourceAABB = math.polyline.getAABB(sourcePolyline);
+    const targetAABB = math.polyline.getAABB(targetPolyline);
+    const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
+    if (!aabbIntersect) {
+        return { hasIntersection: false, isContourHole: false };
+    }
+    const lineSegmentsIntersect = math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
+    const isContourHole = !lineSegmentsIntersect &&
+        math.polyline.containsPoints(targetPolyline, sourcePolyline);
+    const hasIntersection = lineSegmentsIntersect || isContourHole;
+    return { hasIntersection, isContourHole };
+}
+export function getContourHolesData(viewport, annotation) {
+    return getChildAnnotations(annotation).map((holeAnnotation) => {
+        const contourHoleAnnotation = holeAnnotation;
+        const polyline = convertContourPolylineToCanvasSpace(contourHoleAnnotation.data.contour.polyline, viewport);
+        return { annotation: contourHoleAnnotation, polyline };
+    });
+}
+export function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
+    addChildAnnotation(targetAnnotation, holeAnnotation);
+    removeContourSegmentationAnnotation(holeAnnotation);
+    const { contour: holeContour } = holeAnnotation.data;
+    const holePolylineCanvas = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
+    updateContourPolyline(holeAnnotation, {
+        points: holePolylineCanvas,
+        closed: holeContour.closed,
+        targetWindingDirection: targetAnnotation.data.contour.windingDirection ===
+            ContourWindingDirection.Clockwise
+            ? ContourWindingDirection.CounterClockwise
+            : ContourWindingDirection.Clockwise,
+    }, viewport);
+    const { element } = viewport;
+    updateViewportsForAnnotations(viewport, [targetAnnotation, holeAnnotation]);
+}
+export function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline) {
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered in cornerstone. Cannot combine polylines.`);
+        return;
+    }
+    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 { 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 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));
+    }
+    updateViewportsForAnnotations(viewport, [targetAnnotation, sourceAnnotation]);
+}
+export function createNewAnnotationFromPolyline(viewport, templateAnnotation, polyline) {
+    const startPointWorld = viewport.canvasToWorld(polyline[0]);
+    const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
+    const newAnnotation = {
+        metadata: {
+            ...templateAnnotation.metadata,
+            toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
+            originalToolName: templateAnnotation.metadata.originalToolName ||
+                templateAnnotation.metadata.toolName,
+        },
+        data: {
+            cachedStats: {},
+            handles: {
+                points: [startPointWorld, endPointWorld],
+                textBox: templateAnnotation.data.handles.textBox
+                    ? { ...templateAnnotation.data.handles.textBox }
+                    : undefined,
+            },
+            contour: {
+                polyline: [],
+                closed: true,
+            },
+            spline: templateAnnotation.data.spline,
+            segmentation: {
+                ...templateAnnotation.data.segmentation,
+            },
+        },
+        annotationUID: csUtils.uuidv4(),
+        highlighted: true,
+        invalidated: true,
+        isLocked: false,
+        isVisible: undefined,
+        interpolationUID: templateAnnotation.interpolationUID,
+        interpolationCompleted: templateAnnotation.interpolationCompleted,
+    };
+    updateContourPolyline(newAnnotation, {
+        points: polyline,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+    }, viewport);
+    return newAnnotation;
+}
+export function updateViewportsForAnnotations(viewport, annotations) {
+    const { element } = viewport;
+    const updatedToolNames = new Set([DEFAULT_CONTOUR_SEG_TOOL_NAME]);
+    annotations.forEach((annotation) => {
+        updatedToolNames.add(annotation.metadata.toolName);
+    });
+    for (const toolName of updatedToolNames.values()) {
+        if (hasToolByName(toolName)) {
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, toolName);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function unifyPolylineSets(polylinesSetA: Types.Point2[][], polylinesSetB: Types.Point2[][]): Types.Point2[][];
+export declare function unifyMultiplePolylineSets(polylineSets: Types.Point2[][][]): Types.Point2[][];
+export declare function unifyAnnotationPolylines(annotationsSetA: Array<{
+    data: {
+        contour: {
+            polyline: Types.Point3[];
+        };
+    };
+}>, annotationsSetB: Array<{
+    data: {
+        contour: {
+            polyline: Types.Point3[];
+        };
+    };
+}>, viewport: Types.IViewport): Types.Point2[][];
+export declare function subtractPolylineSets(polylinesSetA: Types.Point2[][], polylinesSetB: Types.Point2[][]): Types.Point2[][];
+export declare function subtractMultiplePolylineSets(basePolylineSet: Types.Point2[][], subtractorSets: Types.Point2[][][]): Types.Point2[][];
+export declare function subtractAnnotationPolylines(baseAnnotations: Array<{
+    data: {
+        contour: {
+            polyline: Types.Point3[];
+        };
+    };
+}>, subtractorAnnotations: Array<{
+    data: {
+        contour: {
+            polyline: Types.Point3[];
+        };
+    };
+}>, viewport: Types.IViewport): Types.Point2[][];

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

@@ -0,0 +1,110 @@
+import * as math from '../math';
+import { checkIntersection } from './sharedOperations';
+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];
+            const intersection = checkIntersection(polylineA, polylineB);
+            if (intersection.hasIntersection && !intersection.isContourHole) {
+                const mergedPolyline = math.polyline.mergePolylines(polylineA, polylineB);
+                result.push(mergedPolyline);
+                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;
+}
+export function unifyMultiplePolylineSets(polylineSets) {
+    if (polylineSets.length === 0) {
+        return [];
+    }
+    if (polylineSets.length === 1) {
+        return polylineSets[0].map((polyline) => [...polyline]);
+    }
+    let result = polylineSets[0].map((polyline) => [...polyline]);
+    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) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
+    const polylinesSetB = annotationsSetB.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
+    return unifyPolylineSets(polylinesSetA, polylinesSetB);
+}
+function convertPolylineToCanvasSpace(polyline, viewport) {
+    const numPoints = polyline.length;
+    const projectedPolyline = new Array(numPoints);
+    for (let i = 0; i < numPoints; i++) {
+        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+    }
+    return projectedPolyline;
+}
+export function subtractPolylineSets(polylinesSetA, polylinesSetB) {
+    const result = [];
+    const processedFromA = new Set();
+    for (let i = 0; i < polylinesSetA.length; i++) {
+        if (processedFromA.has(i)) {
+            continue;
+        }
+        let currentPolylines = [polylinesSetA[i]];
+        let wasSubtracted = false;
+        for (let j = 0; j < polylinesSetB.length; j++) {
+            const polylineB = polylinesSetB[j];
+            const newPolylines = [];
+            for (const currentPolyline of currentPolylines) {
+                const intersection = checkIntersection(currentPolyline, polylineB);
+                if (intersection.hasIntersection && !intersection.isContourHole) {
+                    const subtractedPolylines = math.polyline.subtractPolylines(currentPolyline, polylineB);
+                    newPolylines.push(...subtractedPolylines);
+                    wasSubtracted = true;
+                }
+                else {
+                    newPolylines.push(currentPolyline);
+                }
+            }
+            currentPolylines = newPolylines;
+        }
+        result.push(...currentPolylines);
+        processedFromA.add(i);
+    }
+    return result;
+}
+export function subtractMultiplePolylineSets(basePolylineSet, subtractorSets) {
+    if (subtractorSets.length === 0) {
+        return basePolylineSet.map((polyline) => [...polyline]);
+    }
+    let result = basePolylineSet.map((polyline) => [...polyline]);
+    for (let i = 0; i < subtractorSets.length; i++) {
+        result = subtractPolylineSets(result, subtractorSets[i]);
+    }
+    return result;
+}
+export function subtractAnnotationPolylines(baseAnnotations, subtractorAnnotations, viewport) {
+    const basePolylines = baseAnnotations.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
+    const subtractorPolylines = subtractorAnnotations.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
+    return subtractPolylineSets(basePolylines, subtractorPolylines);
+}

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

@@ -6,7 +6,7 @@ import EventTypes from '../../../enums/Events';
 import * as annotationState from '../../../stateManagement/annotation';
 import selectHandles from './selectHandles';
 import updateChildInterpolationUID from './updateChildInterpolationUID';
-import { createPolylineHole } from '../../../eventListeners/annotations/contourSegmentation/contourSegmentationCompleted';
+import { createPolylineHole } from '../../contourSegmentation';
 const { PointsManager } = utilities;
 const dP = 0.2;
 function interpolate(viewportData) {

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

@@ -144,7 +144,10 @@ function mergePolylines(targetPolyline, sourcePolyline) {
     }
     const mergedPolyline = [startPoint.coordinates];
     let currentPoint = startPoint.next;
-    while (currentPoint !== startPoint) {
+    let iterationCount = 0;
+    const maxIterations = targetPolyline.length + sourcePolyline.length + 1000;
+    while (currentPoint !== startPoint && iterationCount < maxIterations) {
+        iterationCount++;
         if (currentPoint.type === PolylinePointType.Intersection &&
             currentPoint.cloned) {
             currentPoint = currentPoint.next;
@@ -152,6 +155,13 @@ function mergePolylines(targetPolyline, sourcePolyline) {
         }
         mergedPolyline.push(currentPoint.coordinates);
         currentPoint = currentPoint.next;
+        if (!currentPoint) {
+            console.warn('Broken linked list detected in mergePolylines, breaking loop');
+            break;
+        }
+    }
+    if (iterationCount >= maxIterations) {
+        console.warn('Maximum iterations reached in mergePolylines, possible infinite loop detected');
     }
     return mergedPolyline;
 }
@@ -165,11 +175,19 @@ function subtractPolylines(targetPolyline, sourcePolyline) {
     const { targetPolylinePoints } = getSourceAndTargetPointsList(targetPolyline, sourcePolyline);
     let startPoint = null;
     const subtractedPolylines = [];
-    while ((startPoint = getUnvisitedOutsidePoint(targetPolylinePoints))) {
+    let outerIterationCount = 0;
+    const maxOuterIterations = targetPolyline.length * 2;
+    while ((startPoint = getUnvisitedOutsidePoint(targetPolylinePoints)) &&
+        outerIterationCount < maxOuterIterations) {
+        outerIterationCount++;
         const subtractedPolyline = [startPoint.coordinates];
         let currentPoint = startPoint.next;
+        let innerIterationCount = 0;
+        const maxInnerIterations = targetPolyline.length + sourcePolyline.length + 1000;
         startPoint.visited = true;
-        while (currentPoint !== startPoint) {
+        while (currentPoint !== startPoint &&
+            innerIterationCount < maxInnerIterations) {
+            innerIterationCount++;
             currentPoint.visited = true;
             if (currentPoint.type === PolylinePointType.Intersection &&
                 currentPoint.cloned) {
@@ -178,9 +196,19 @@ function subtractPolylines(targetPolyline, sourcePolyline) {
             }
             subtractedPolyline.push(currentPoint.coordinates);
             currentPoint = currentPoint.next;
+            if (!currentPoint) {
+                console.warn('Broken linked list detected in subtractPolylines, breaking inner loop');
+                break;
+            }
+        }
+        if (innerIterationCount >= maxInnerIterations) {
+            console.warn('Maximum inner iterations reached in subtractPolylines, possible infinite loop detected');
         }
         subtractedPolylines.push(subtractedPolyline);
     }
+    if (outerIterationCount >= maxOuterIterations) {
+        console.warn('Maximum outer iterations reached in subtractPolylines, possible infinite loop detected');
+    }
     return subtractedPolylines;
 }
 export { mergePolylines, subtractPolylines };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.19.1";
+export declare const version = "3.19.3";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.19.1';
+export const version = '3.19.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.19.1",
+  "version": "3.19.3",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.19.1",
+    "@cornerstonejs/core": "^3.19.3",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "bbd1940e51060d73897b9f9021c8453ac928550f"
+  "gitHead": "dd1f16a4bfbced2de7ef786a3d3b3205aa661543"
 }