@cornerstonejs/tools 5.1.3 → 5.2.0

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

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

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

@@ -1,4 +1,4 @@
-import * as math from '../math';
+import * as math from '../math/index.js';
 function findAllIntersectingContours(viewport, sourcePolyline, contourSegmentationAnnotations) {
     const intersectingContours = [];
     const sourceAABB = math.polyline.getAABB(sourcePolyline);

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

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationAnnotation } from '../../types';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
 export declare function getViewReferenceFromAnnotation(annotation: ContourSegmentationAnnotation): Types.ViewReference;

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

@@ -1,16 +1,16 @@
-import areSameSegment from './areSameSegment';
-import convertContourSegmentationAnnotation from './convertContourSegmentation';
-import { copyAnnotation, copyContourSegment } from './copyAnnotation';
-export * 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';
+import areSameSegment from './areSameSegment.js';
+import convertContourSegmentationAnnotation from './convertContourSegmentation.js';
+import { copyAnnotation, copyContourSegment } from './copyAnnotation.js';
+export * from './logicalOperators.js';
+export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation.js';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation.js';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+export { findAllIntersectingContours } from './getIntersectingAnnotations.js';
+export { processMultipleIntersections } from './mergeMultipleAnnotations.js';
+export { contourSegmentationOperation } from './contourSegmentationOperation.js';
+export * from './sharedOperations.js';
 export { areSameSegment, convertContourSegmentationAnnotation, copyContourSegment, copyAnnotation, };
-export * from './polylineUnify';
-export * from './polylineSubtract';
-export * from './polylineIntersect';
-export * from './polylineXor';
+export * from './polylineUnify.js';
+export * from './polylineSubtract.js';
+export * from './polylineIntersect.js';
+export * from './polylineXor.js';

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

@@ -1,16 +1,16 @@
-import areSameSegment from './areSameSegment';
-import convertContourSegmentationAnnotation from './convertContourSegmentation';
-import { copyAnnotation, copyContourSegment } from './copyAnnotation';
-export * 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';
+import areSameSegment from './areSameSegment.js';
+import convertContourSegmentationAnnotation from './convertContourSegmentation.js';
+import { copyAnnotation, copyContourSegment } from './copyAnnotation.js';
+export * from './logicalOperators.js';
+export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation.js';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation.js';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+export { findAllIntersectingContours } from './getIntersectingAnnotations.js';
+export { processMultipleIntersections } from './mergeMultipleAnnotations.js';
+export { contourSegmentationOperation } from './contourSegmentationOperation.js';
+export * from './sharedOperations.js';
 export { areSameSegment, convertContourSegmentationAnnotation, copyContourSegment, copyAnnotation, };
-export * from './polylineUnify';
-export * from './polylineSubtract';
-export * from './polylineIntersect';
-export * from './polylineXor';
+export * from './polylineUnify.js';
+export * from './polylineSubtract.js';
+export * from './polylineIntersect.js';
+export * from './polylineXor.js';

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

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

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

@@ -1,15 +1,15 @@
-import { getAnnotation, removeAnnotation } from '../../stateManagement';
-import { convertContourPolylineToCanvasSpace, convertContourPolylineToWorld, } from './sharedOperations';
-import addPolylinesToSegmentation from './addPolylinesToSegmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
-import { copyContourSegment } from './copyAnnotation';
-import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
-import { getViewportAssociatedToSegmentation } from '../../stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation';
-import { unifyPolylineSets } from './polylineUnify';
-import { subtractPolylineSets } from './polylineSubtract';
-import { intersectPolylinesSets } from './polylineIntersect';
-import { xorPolylinesSets } from './polylineXor';
-import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation';
+import { getAnnotation, removeAnnotation, getChildAnnotations, } from '../../stateManagement/index.js';
+import { convertContourPolylineToCanvasSpace, convertContourPolylineToWorld, } from './sharedOperations.js';
+import addPolylinesToSegmentation from './addPolylinesToSegmentation.js';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation.js';
+import { copyContourSegment } from './copyAnnotation.js';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation.js';
+import { getViewportAssociatedToSegmentation } from '../../stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation.js';
+import { unifyPolylineSets } from './polylineUnify.js';
+import { subtractPolylineSets } from './polylineSubtract.js';
+import { intersectPolylinesSets } from './polylineIntersect.js';
+import { xorPolylinesSets } from './polylineXor.js';
+import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation.js';
 export var LogicalOperation;
 (function (LogicalOperation) {
     LogicalOperation[LogicalOperation["Union"] = 0] = "Union";
@@ -29,9 +29,14 @@ function getPolylinesInfoWorld(contourRepresentationData, segmentIndex) {
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
         const { polyline } = annotation.data.contour;
+        const childAnnotations = getChildAnnotations(annotation);
+        const holePolylines = childAnnotations.length > 0
+            ? childAnnotations.map((child) => child.data.contour.polyline)
+            : undefined;
         polylinesInfo.push({
             polyline,
             viewReference: getViewReferenceFromAnnotation(annotation),
+            ...(holePolylines ? { holePolylines } : {}),
         });
     }
     return polylinesInfo;
@@ -51,16 +56,26 @@ function extractPolylinesInCanvasSpace(viewport, segment1, segment2) {
     if (!polyLinesInfoWorld1 || !polyLinesInfoWorld2) {
         return;
     }
-    const polyLinesInfoCanvas1 = polyLinesInfoWorld1.map(({ polyline, viewReference }) => {
+    const polyLinesInfoCanvas1 = polyLinesInfoWorld1.map(({ polyline, viewReference, holePolylines }) => {
         return {
             polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
             viewReference,
+            ...(holePolylines?.length
+                ? {
+                    holePolylines: holePolylines.map((hole) => convertContourPolylineToCanvasSpace(hole, viewport)),
+                }
+                : {}),
         };
     });
-    const polyLinesInfoCanvas2 = polyLinesInfoWorld2.map(({ polyline, viewReference }) => {
+    const polyLinesInfoCanvas2 = polyLinesInfoWorld2.map(({ polyline, viewReference, holePolylines }) => {
         return {
             polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
             viewReference,
+            ...(holePolylines?.length
+                ? {
+                    holePolylines: holePolylines.map((hole) => convertContourPolylineToCanvasSpace(hole, viewport)),
+                }
+                : {}),
         };
     });
     return { polyLinesInfoCanvas1, polyLinesInfoCanvas2 };
@@ -120,12 +135,15 @@ function applyLogicalOperation(segment1, segment2, options, operation) {
             polylinesMerged = unifyPolylineSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
             break;
     }
-    const polyLinesWorld = polylinesMerged.map(({ polyline, viewReference }) => {
-        return {
-            polyline: convertContourPolylineToWorld(polyline, viewport),
-            viewReference,
-        };
-    });
+    const polyLinesWorld = polylinesMerged.map(({ polyline, viewReference, holePolylines }) => ({
+        polyline: convertContourPolylineToWorld(polyline, viewport),
+        viewReference,
+        ...(holePolylines?.length
+            ? {
+                holePolylines: holePolylines.map((hole) => convertContourPolylineToWorld(hole, viewport)),
+            }
+            : {}),
+    }));
     const resultSegment = options;
     const segmentation = getSegmentation(resultSegment.segmentationId);
     const segmentIndex = resultSegment.segmentIndex;

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation.js';
 declare function processMultipleIntersections(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation, sourcePolyline: Types.Point2[], intersectingContours: Array<{
     targetAnnotation: ContourSegmentationAnnotation;
     targetPolyline: Types.Point2[];

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

@@ -1,14 +1,15 @@
 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';
+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, hasTool } from '../../store/addTool.js';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps.js';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 function processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline, intersectingContours) {
     const holeOperations = intersectingContours.filter((item) => item.isContourHole);
@@ -33,51 +34,52 @@ function processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline
 }
 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 subjects = mergeOperations.map(({ targetAnnotation, targetPolyline }) => {
+        const holes = getContourHolesData(viewport, targetAnnotation).map((h) => h.polyline);
+        return {
+            outer: targetPolyline,
+            holes: holes.length ? holes : undefined,
+        };
     });
+    const clips = [{ outer: sourcePolyline }];
     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) => {
+    const op = shouldMerge ? BooleanOp.Union : BooleanOp.Difference;
+    const resultPolygons = applyBoolean(subjects, clips, op);
+    const allHoleAnnotations = [];
+    const allAnnotationsToRemove = [
+        sourceAnnotation,
+    ];
+    mergeOperations.forEach(({ targetAnnotation }) => {
+        allAnnotationsToRemove.push(targetAnnotation);
+        getContourHolesData(viewport, targetAnnotation).forEach((h) => allHoleAnnotations.push(h.annotation));
+    });
+    [...allAnnotationsToRemove, ...allHoleAnnotations].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);
+    resultPolygons.forEach((polygon) => {
+        if (polygon.outer.length < 3) {
             return;
         }
-        const newAnnotation = createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline);
-        addAnnotation(newAnnotation, element);
-        addContourSegmentationAnnotation(newAnnotation);
-        triggerAnnotationModified(newAnnotation, viewport.element);
-        newAnnotations.push(newAnnotation);
+        const parent = createNewAnnotationFromPolyline(viewport, baseAnnotation, 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, baseAnnotation, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
     });
-    reassignHolesToNewAnnotations(viewport, allHoles, newAnnotations);
     updateViewportsForAnnotations(viewport, allAnnotationsToRemove);
 }
-function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline) {
+function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline, windingDirection = ContourWindingDirection.Clockwise) {
     const startPointWorld = viewport.canvasToWorld(polyline[0]);
     const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
     const newAnnotation = {
@@ -115,21 +117,10 @@ function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline) {
     updateContourPolyline(newAnnotation, {
         points: polyline,
         closed: true,
-        targetWindingDirection: ContourWindingDirection.Clockwise,
+        targetWindingDirection: windingDirection,
     }, 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;

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

@@ -2,8 +2,10 @@ import type { Types } from '@cornerstonejs/core';
 export type PolylineInfoWorld = {
     polyline: Types.Point3[];
     viewReference: Types.ViewReference;
+    holePolylines?: Types.Point3[][];
 };
 export type PolylineInfoCanvas = {
     polyline: Types.Point2[];
     viewReference: Types.ViewReference;
+    holePolylines?: Types.Point2[][];
 };

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

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

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

@@ -1,34 +1,5 @@
-import { checkIntersection, cleanupPolylines } from './sharedOperations';
-import { intersectPolylines } from '../math/polyline';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps.js';
+import { BooleanOp } from './clipperBooleanOps.js';
 export function intersectPolylinesSets(set1, set2) {
-    if (!set1.length || !set2.length) {
-        return [];
-    }
-    const result = [];
-    for (const polyA of set1) {
-        for (const polyB of set2) {
-            if (!areViewReferencesEqual(polyA.viewReference, polyB.viewReference)) {
-                continue;
-            }
-            if (arePolylinesIdentical(polyA.polyline, polyB.polyline)) {
-                result.push({ ...polyA });
-                continue;
-            }
-            const intersection = checkIntersection(polyA.polyline, polyB.polyline);
-            if (intersection.hasIntersection && !intersection.isContourHole) {
-                const intersectionRegions = cleanupPolylines(intersectPolylines(polyA.polyline, polyB.polyline));
-                if (intersectionRegions && intersectionRegions.length > 0) {
-                    intersectionRegions.forEach((region) => {
-                        result.push({
-                            polyline: region,
-                            viewReference: polyA.viewReference,
-                        });
-                    });
-                }
-            }
-        }
-    }
-    return result;
+    return runBooleanOpByView(set1, set2, BooleanOp.Intersection);
 }

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

@@ -0,0 +1,3 @@
+import type { PolylineInfoCanvas } from './polylineInfoTypes.js';
+import { BooleanOp } from './clipperBooleanOps.js';
+export declare function runBooleanOpByView(setA: PolylineInfoCanvas[], setB: PolylineInfoCanvas[], op: BooleanOp): PolylineInfoCanvas[];

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

@@ -0,0 +1,62 @@
+import { areViewReferencesEqual } from './areViewReferencesEqual.js';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps.js';
+function toPolygon(info) {
+    return {
+        outer: info.polyline,
+        holes: info.holePolylines?.length ? info.holePolylines : undefined,
+    };
+}
+function groupByViewReference(set) {
+    const groups = [];
+    for (const info of set) {
+        if (info.polyline.length < 3) {
+            continue;
+        }
+        const existing = groups.find((g) => areViewReferencesEqual(g.viewReference, info.viewReference));
+        if (existing) {
+            existing.polygons.push(toPolygon(info));
+        }
+        else {
+            groups.push({
+                viewReference: info.viewReference,
+                polygons: [toPolygon(info)],
+            });
+        }
+    }
+    return groups;
+}
+function flatten(result, viewReference) {
+    return result.map((p) => ({
+        polyline: p.outer,
+        viewReference,
+        ...(p.holes?.length ? { holePolylines: p.holes } : {}),
+    }));
+}
+export function runBooleanOpByView(setA, setB, op) {
+    const aGroups = groupByViewReference(setA);
+    const bGroups = groupByViewReference(setB);
+    const out = [];
+    const matchedB = new Set();
+    for (const aGroup of aGroups) {
+        const bGroup = bGroups.find((g) => areViewReferencesEqual(g.viewReference, aGroup.viewReference));
+        if (bGroup) {
+            matchedB.add(bGroup);
+            const result = applyBoolean(aGroup.polygons, bGroup.polygons, op);
+            out.push(...flatten(result, aGroup.viewReference));
+        }
+        else if (op === BooleanOp.Intersection) {
+        }
+        else {
+            out.push(...flatten(aGroup.polygons, aGroup.viewReference));
+        }
+    }
+    if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+        for (const bGroup of bGroups) {
+            if (matchedB.has(bGroup)) {
+                continue;
+            }
+            out.push(...flatten(bGroup.polygons, bGroup.viewReference));
+        }
+    }
+    return out;
+}

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-import type { PolylineInfoCanvas } from './polylineInfoTypes';
-import type { ContourSegmentationAnnotation } from '../../types';
+import type { PolylineInfoCanvas } from './polylineInfoTypes.js';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
 export declare function subtractPolylineSets(polylinesSetA: PolylineInfoCanvas[], polylinesSetB: PolylineInfoCanvas[]): PolylineInfoCanvas[];
 export declare function subtractMultiplePolylineSets(basePolylineSet: PolylineInfoCanvas[], subtractorSets: PolylineInfoCanvas[][]): PolylineInfoCanvas[];
 export declare function subtractAnnotationPolylines(baseAnnotations: ContourSegmentationAnnotation[], subtractorAnnotations: ContourSegmentationAnnotation[], viewport: Types.IViewport): PolylineInfoCanvas[];

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

@@ -1,67 +1,29 @@
-import * as math from '../math';
-import { checkIntersection, cleanupPolylines, convertContourPolylineToCanvasSpace, removeDuplicatePoints, } 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 subtractPolylineSets(polylinesSetA, polylinesSetB) {
-    const result = [];
-    for (let i = 0; i < polylinesSetA.length; i++) {
-        let currentPolylines = [polylinesSetA[i]];
-        for (let j = 0; j < polylinesSetB.length; j++) {
-            const polylineB = polylinesSetB[j];
-            const newPolylines = [];
-            for (const currentPolyline of currentPolylines) {
-                if (!areViewReferencesEqual(currentPolyline.viewReference, polylineB.viewReference)) {
-                    newPolylines.push(currentPolyline);
-                    continue;
-                }
-                if (arePolylinesIdentical(currentPolyline.polyline, polylineB.polyline)) {
-                    continue;
-                }
-                const intersection = checkIntersection(currentPolyline.polyline, polylineB.polyline);
-                if (intersection.hasIntersection && !intersection.isContourHole) {
-                    const subtractedPolylines = cleanupPolylines(math.polyline.subtractPolylines(currentPolyline.polyline, polylineB.polyline));
-                    for (const subtractedPolyline of subtractedPolylines) {
-                        const cleaned = removeDuplicatePoints(subtractedPolyline);
-                        if (cleaned.length >= 3) {
-                            newPolylines.push({
-                                polyline: cleaned,
-                                viewReference: currentPolyline.viewReference,
-                            });
-                        }
-                    }
-                }
-                else {
-                    newPolylines.push({
-                        polyline: currentPolyline.polyline,
-                        viewReference: currentPolyline.viewReference,
-                    });
-                }
-            }
-            currentPolylines = newPolylines;
-        }
-        result.push(...currentPolylines);
-    }
-    return result;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Difference);
 }
 export function subtractMultiplePolylineSets(basePolylineSet, subtractorSets) {
     if (subtractorSets.length === 0) {
         return [...basePolylineSet];
     }
-    let result = [...basePolylineSet];
-    for (let i = 0; i < subtractorSets.length; i++) {
-        result = subtractPolylineSets(result, subtractorSets[i]);
+    let result = basePolylineSet;
+    for (const subtractor of subtractorSets) {
+        result = subtractPolylineSets(result, subtractor);
     }
     return result;
 }
 export function subtractAnnotationPolylines(baseAnnotations, subtractorAnnotations, viewport) {
-    const basePolylines = baseAnnotations.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    const subtractorPolylines = subtractorAnnotations.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    return subtractPolylineSets(basePolylines, subtractorPolylines);
+    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 subtractPolylineSets(baseAnnotations.map(toInfo), subtractorAnnotations.map(toInfo));
 }

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-import type { PolylineInfoCanvas } from './polylineInfoTypes';
-import type { ContourSegmentationAnnotation } from '../../types';
+import type { PolylineInfoCanvas } from './polylineInfoTypes.js';
+import type { ContourSegmentationAnnotation } from '../../types/index.js';
 export declare function unifyPolylineSets(polylinesSetA: PolylineInfoCanvas[], polylinesSetB: PolylineInfoCanvas[]): PolylineInfoCanvas[];
 export declare function unifyMultiplePolylineSets(polylineSets: PolylineInfoCanvas[][]): PolylineInfoCanvas[];
 export declare function unifyAnnotationPolylines(annotationsSetA: ContourSegmentationAnnotation[], annotationsSetB: ContourSegmentationAnnotation[], viewport: Types.IViewport): PolylineInfoCanvas[];