@cornerstonejs/tools 3.24.0 → 3.25.0

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

@@ -1,75 +1,180 @@
-import { getAnnotation } from '../../stateManagement';
+import { getAnnotation, removeAnnotation } 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;
+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';
+export var LogicalOperation;
+(function (LogicalOperation) {
+    LogicalOperation[LogicalOperation["Union"] = 0] = "Union";
+    LogicalOperation[LogicalOperation["Subtract"] = 1] = "Subtract";
+    LogicalOperation[LogicalOperation["Intersect"] = 2] = "Intersect";
+    LogicalOperation[LogicalOperation["XOR"] = 3] = "XOR";
+    LogicalOperation[LogicalOperation["Copy"] = 4] = "Copy";
+    LogicalOperation[LogicalOperation["Delete"] = 5] = "Delete";
+})(LogicalOperation || (LogicalOperation = {}));
+function getPolylinesInfoWorld(contourRepresentationData, segmentIndex) {
+    const polylinesInfo = [];
+    const { annotationUIDsMap } = contourRepresentationData || {};
+    if (!annotationUIDsMap?.has(segmentIndex)) {
+        return;
+    }
     const annotationUIDs = annotationUIDsMap.get(segmentIndex);
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
-        const { polyline } = annotation.data
-            .contour;
-        polylines.push(polyline);
+        const { polyline } = annotation.data.contour;
+        polylinesInfo.push({
+            polyline,
+            viewReference: getViewReferenceFromAnnotation(annotation),
+        });
     }
-    return polylines;
+    return polylinesInfo;
 }
-function extractPolylines(viewport, segmentation, segmentIndex1, segmentIndex2) {
-    if (!segmentation) {
+function extractPolylinesInCanvasSpace(viewport, segment1, segment2) {
+    const segmentation1 = getSegmentation(segment1.segmentationId);
+    const segmentation2 = getSegmentation(segment2.segmentationId);
+    if (!segmentation1 || !segmentation2) {
         return;
     }
-    if (!segmentation.representationData.Contour) {
+    if (!segmentation1.representationData.Contour ||
+        !segmentation2.representationData.Contour) {
         return;
     }
-    const contourRepresentationData = segmentation.representationData
-        .Contour;
-    const { annotationUIDsMap } = contourRepresentationData;
-    if (!annotationUIDsMap) {
+    const polyLinesInfoWorld1 = getPolylinesInfoWorld(segmentation1.representationData.Contour, segment1.segmentIndex);
+    const polyLinesInfoWorld2 = getPolylinesInfoWorld(segmentation2.representationData.Contour, segment2.segmentIndex);
+    if (!polyLinesInfoWorld1 || !polyLinesInfoWorld2) {
         return;
     }
-    if (!annotationUIDsMap.get(segmentIndex1)) {
+    const polyLinesInfoCanvas1 = polyLinesInfoWorld1.map(({ polyline, viewReference }) => {
+        return {
+            polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
+            viewReference,
+        };
+    });
+    const polyLinesInfoCanvas2 = polyLinesInfoWorld2.map(({ polyline, viewReference }) => {
+        return {
+            polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
+            viewReference,
+        };
+    });
+    return { polyLinesInfoCanvas1, polyLinesInfoCanvas2 };
+}
+function addSegmentInSegmentation(segmentation, { segmentIndex, label, color }) {
+    if (!segmentation?.segments) {
         return;
     }
-    if (!annotationUIDsMap.get(segmentIndex2)) {
+    segmentation.segments[segmentIndex] = {
+        active: false,
+        locked: false,
+        label,
+        segmentIndex,
+        cachedStats: {},
+        color,
+    };
+}
+function removeAnnotations(annotationUIDList) {
+    annotationUIDList.forEach((annotationUID) => {
+        const annotation = getAnnotation(annotationUID);
+        removeAnnotation(annotationUID);
+        removeContourSegmentationAnnotation(annotation);
+    });
+    annotationUIDList.clear();
+}
+function applyLogicalOperation(segment1, segment2, options, operation) {
+    const viewport = getViewportAssociatedToSegmentation(segment1.segmentationId);
+    if (!viewport) {
         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) {
+    const { polyLinesInfoCanvas1, polyLinesInfoCanvas2 } = extractPolylinesInCanvasSpace(viewport, segment1, segment2) || {};
+    if (!polyLinesInfoCanvas1 || !polyLinesInfoCanvas2) {
         return;
     }
-    const polylinesMerged = unifyPolylineSets(polyLinesCanvas1, polyLinesCanvas2);
-    const polyLinesWorld = polylinesMerged.map((polyline) => convertContourPolylineToWorld(polyline, viewport));
-    const annotationUIDsMapNew = addPolylinesToSegmentation(viewport, segmentation.segmentationId, polyLinesWorld, segmentIndex);
+    let polylinesMerged;
+    switch (operation) {
+        case LogicalOperation.Union:
+            polylinesMerged = unifyPolylineSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
+            break;
+        case LogicalOperation.Subtract:
+            polylinesMerged = subtractPolylineSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
+            break;
+        case LogicalOperation.Intersect:
+            polylinesMerged = intersectPolylinesSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
+            break;
+        case LogicalOperation.XOR:
+            polylinesMerged = xorPolylinesSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
+            break;
+        default:
+            polylinesMerged = unifyPolylineSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
+            break;
+    }
+    const polyLinesWorld = polylinesMerged.map(({ polyline, viewReference }) => {
+        return {
+            polyline: convertContourPolylineToWorld(polyline, viewport),
+            viewReference,
+        };
+    });
+    const resultSegment = options;
+    const segmentation = getSegmentation(resultSegment.segmentationId);
+    const segmentIndex = resultSegment.segmentIndex;
+    const color = resultSegment.color;
+    const label = resultSegment.label;
     const contourRepresentationData = segmentation.representationData
         .Contour;
     const { annotationUIDsMap } = contourRepresentationData;
     if (!annotationUIDsMap) {
         return;
     }
-    annotationUIDsMap.set(segmentIndex, annotationUIDsMapNew.get(segmentIndex));
+    if (segment1.segmentationId === resultSegment.segmentationId &&
+        segment1.segmentIndex === segmentIndex) {
+        const existingAnnotationUIDs = annotationUIDsMap.get(segmentIndex);
+        if (existingAnnotationUIDs) {
+            removeAnnotations(existingAnnotationUIDs);
+        }
+    }
+    addPolylinesToSegmentation(viewport, annotationUIDsMap, segmentation.segmentationId, polyLinesWorld, segmentIndex);
+    addSegmentInSegmentation(segmentation, { segmentIndex, color, label });
+}
+export function add(segment1, segment2, options) {
+    applyLogicalOperation(segment1, segment2, options, LogicalOperation.Union);
+}
+export function subtract(segment1, segment2, options) {
+    applyLogicalOperation(segment1, segment2, options, LogicalOperation.Subtract);
+}
+export function intersect(segment1, segment2, options) {
+    applyLogicalOperation(segment1, segment2, options, LogicalOperation.Intersect);
 }
-export function subtraction(viewport, segmentation, segmentIndex1, segmentIndex2, { name, segmentIndex, color }) {
-    const { polyLinesCanvas1, polyLinesCanvas2 } = extractPolylines(viewport, segmentation, segmentIndex1, segmentIndex2) ||
-        {};
-    if (!polyLinesCanvas1 || polyLinesCanvas2) {
+export function xor(segment1, segment2, options) {
+    applyLogicalOperation(segment1, segment2, options, LogicalOperation.XOR);
+}
+export function copy(segment, options) {
+    copyContourSegment(segment.segmentationId, segment.segmentIndex, options.segmentationId, options.segmentIndex);
+}
+export function deleteOperation(segment) {
+    const segmentation = getSegmentation(segment.segmentationId);
+    if (!segmentation) {
+        console.log('No active segmentation detected');
         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 (!segmentation.representationData.Contour) {
+        console.log('No contour representation found');
+        return;
+    }
+    const representationData = segmentation.representationData.Contour;
+    const { annotationUIDsMap } = representationData;
     if (!annotationUIDsMap) {
+        console.log('No annotation map found');
+        return;
+    }
+    if (!annotationUIDsMap.has(segment.segmentIndex)) {
+        console.log('Segmentation index has no annotations');
         return;
     }
-    annotationUIDsMap.set(segmentIndex, annotationUIDsMapNew.get(segmentIndex));
+    const annotationUIDList = annotationUIDsMap.get(segment.segmentIndex);
+    removeAnnotations(annotationUIDList);
 }

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

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+export type PolylineInfoWorld = {
+    polyline: Types.Point3[];
+    viewReference: Types.ViewReference;
+};
+export type PolylineInfoCanvas = {
+    polyline: Types.Point2[];
+    viewReference: Types.ViewReference;
+};

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

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

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

@@ -0,0 +1,34 @@
+import { checkIntersection, cleanupPolylines } from './sharedOperations';
+import { intersectPolylines } from '../math/polyline';
+import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
+import { areViewReferencesEqual } from './areViewReferencesEqual';
+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;
+}

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

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PolylineInfoCanvas } from './polylineInfoTypes';
+import type { ContourSegmentationAnnotation } from '../../types';
+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

@@ -0,0 +1,67 @@
+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';
+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;
+}
+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]);
+    }
+    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);
+}

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

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PolylineInfoCanvas } from './polylineInfoTypes';
+import type { ContourSegmentationAnnotation } from '../../types';
+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[];

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

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

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

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

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

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

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

@@ -14,3 +14,5 @@ export declare function createPolylineHole(viewport: Types.IViewport, targetAnno
 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;
+export declare function removeDuplicatePoints(polyline: Types.Point2[]): Types.Point2[];
+export declare function cleanupPolylines(polylines: Types.Point2[][]): Types.Point2[][];

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

@@ -9,6 +9,7 @@ import { triggerAnnotationModified } from '../../stateManagement/annotation/help
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getViewportIdsWithToolToRender } from '../viewportFilters';
 import { hasToolByName } from '../../store/addTool';
+const TOLERANCE = 1e-10;
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export function convertContourPolylineToCanvasSpace(polyline, viewport) {
     const numPoints = polyline.length;
@@ -181,3 +182,46 @@ export function updateViewportsForAnnotations(viewport, annotations) {
         }
     }
 }
+export function removeDuplicatePoints(polyline) {
+    if (!polyline || polyline.length < 2) {
+        return polyline;
+    }
+    const cleaned = [polyline[0]];
+    for (let i = 1; i < polyline.length; i++) {
+        const currentPoint = polyline[i];
+        const lastPoint = cleaned[cleaned.length - 1];
+        const dx = Math.abs(currentPoint[0] - lastPoint[0]);
+        const dy = Math.abs(currentPoint[1] - lastPoint[1]);
+        if (dx > TOLERANCE || dy > TOLERANCE) {
+            cleaned.push(currentPoint);
+        }
+    }
+    return cleaned;
+}
+export function cleanupPolylines(polylines) {
+    const validPolylines = [];
+    const seenPolylines = new Set();
+    for (let polyline of polylines) {
+        if (!polyline || polyline.length < 3) {
+            continue;
+        }
+        polyline = removeDuplicatePoints(polyline);
+        if (polyline.length < 3) {
+            continue;
+        }
+        const sortedPoints = [...polyline].sort((a, b) => {
+            if (a[0] !== b[0]) {
+                return a[0] - b[0];
+            }
+            return a[1] - b[1];
+        });
+        const polylineKey = sortedPoints
+            .map((p) => `${p[0].toFixed(6)},${p[1].toFixed(6)}`)
+            .join('|');
+        if (!seenPolylines.has(polylineKey)) {
+            seenPolylines.add(polylineKey);
+            validPolylines.push(polyline);
+        }
+    }
+    return validPolylines;
+}

package/dist/esm/utilities/math/polyline/arePolylinesIdentical.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function arePolylinesIdentical(poly1: Types.Point2[], poly2: Types.Point2[]): boolean;

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

@@ -0,0 +1,53 @@
+import { pointsAreEqual } from './robustSegmentIntersection';
+export default function arePolylinesIdentical(poly1, poly2) {
+    if (poly1.length !== poly2.length) {
+        return false;
+    }
+    const len = poly1.length;
+    if (len === 0) {
+        return true;
+    }
+    let identicalForward = true;
+    for (let i = 0; i < len; i++) {
+        if (!pointsAreEqual(poly1[i], poly2[i])) {
+            identicalForward = false;
+            break;
+        }
+    }
+    if (identicalForward) {
+        return true;
+    }
+    let identicalReverse = true;
+    for (let i = 0; i < len; i++) {
+        if (!pointsAreEqual(poly1[i], poly2[len - 1 - i])) {
+            identicalReverse = false;
+            break;
+        }
+    }
+    if (identicalReverse) {
+        return true;
+    }
+    for (let offset = 1; offset < len; offset++) {
+        let cyclicForward = true;
+        for (let i = 0; i < len; i++) {
+            if (!pointsAreEqual(poly1[i], poly2[(i + offset) % len])) {
+                cyclicForward = false;
+                break;
+            }
+        }
+        if (cyclicForward) {
+            return true;
+        }
+        let cyclicReverse = true;
+        for (let i = 0; i < len; i++) {
+            if (!pointsAreEqual(poly1[i], poly2[(len - 1 - i + offset) % len])) {
+                cyclicReverse = false;
+                break;
+            }
+        }
+        if (cyclicReverse) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/esm/utilities/math/polyline/combinePolyline.d.ts

@@ -1,4 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
 declare function mergePolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[];
-declare function subtractPolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[][];
-export { mergePolylines, subtractPolylines };
+export { mergePolylines };