@cornerstonejs/tools 3.24.0 → 3.26.0

package/dist/esm/types/index.d.ts

@@ -44,6 +44,7 @@ import type { SplineProps } from './SplineProps';
 import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
 import type { IBaseTool } from './IBaseTool';
 import type { RepresentationStyle } from './../stateManagement/segmentation/SegmentationStyle';
+import type { LogicalOperation } from '../utilities/contourSegmentation';
 import type { LabelmapStyle, LabelmapSegmentationData, LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume, BaseLabelmapStyle, InactiveLabelmapStyle } from './LabelmapTypes';
 import type { SurfaceStyle, SurfaceSegmentationData, SurfaceStateStyles } from './SurfaceTypes';
-export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationRepresentation, SegmentationState, RepresentationData, RepresentationsData, SVGCursorDescriptor, SVGPoint, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, IBaseTool, RepresentationStyle, Segment, SegmentationPublicInput, LabelmapStyle, ContourStyle, SurfaceStyle, SurfaceSegmentationData, SurfaceStateStyles, LabelmapSegmentationData, LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume, BaseLabelmapStyle, InactiveLabelmapStyle, };
+export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationRepresentation, SegmentationState, RepresentationData, RepresentationsData, SVGCursorDescriptor, SVGPoint, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, IBaseTool, RepresentationStyle, Segment, SegmentationPublicInput, LabelmapStyle, ContourStyle, SurfaceStyle, SurfaceSegmentationData, SurfaceStateStyles, LabelmapSegmentationData, LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume, BaseLabelmapStyle, InactiveLabelmapStyle, LogicalOperation, };

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

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

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

@@ -1,9 +1,8 @@
 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) => {
+export default function addPolylinesToSegmentation(viewport, annotationUIDsMap, segmentationId, polylinesInfo, segmentIndex) {
+    polylinesInfo.forEach(({ polyline, viewReference }) => {
         if (polyline.length < 3) {
             return;
         }
@@ -28,7 +27,7 @@ export default function addPolylinesToSegmentation(viewport, segmentationId, pol
             isVisible: true,
             metadata: {
                 toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
-                ...viewport.getViewReference(),
+                ...viewReference,
             },
         };
         addAnnotation(contourSegmentationAnnotation, viewport.element);

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function areViewReferencesEqual(a: Types.ViewReference, b: Types.ViewReference): boolean;

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

@@ -0,0 +1,23 @@
+export function areViewReferencesEqual(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.FrameOfReferenceUID !== b.FrameOfReferenceUID) {
+        return false;
+    }
+    if (a.referencedImageId !== b.referencedImageId) {
+        return false;
+    }
+    if (!a.viewPlaneNormal || !b.viewPlaneNormal) {
+        return false;
+    }
+    if (a.viewPlaneNormal.length !== b.viewPlaneNormal.length) {
+        return false;
+    }
+    for (let i = 0; i < a.viewPlaneNormal.length; i++) {
+        if (a.viewPlaneNormal[i] !== b.viewPlaneNormal[i]) {
+            return false;
+        }
+    }
+    return true;
+}

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

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

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

@@ -0,0 +1,86 @@
+import { utilities } from '@cornerstonejs/core';
+import { addAnnotation, getAnnotation } from '../../stateManagement';
+import { getViewportAssociatedToSegmentation } from '../../stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
+import { getAnnotationsUIDMapFromSegmentation } from '../../stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation';
+export function copyAnnotation(annotation, segmentationId, segmentIndex) {
+    const newAnnotation = {
+        annotationUID: utilities.uuidv4(),
+        data: {
+            contour: {
+                closed: true,
+                polyline: [],
+            },
+            segmentation: {
+                segmentationId,
+                segmentIndex,
+            },
+            handles: {},
+        },
+        handles: {},
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            ...annotation.metadata,
+            toolName: annotation.metadata.toolName,
+        },
+    };
+    newAnnotation.data.segmentation.segmentationId = segmentationId;
+    newAnnotation.data.segmentation.segmentIndex = segmentIndex;
+    if (annotation.data.contour?.polyline) {
+        newAnnotation.data.contour.polyline = [...annotation.data.contour.polyline];
+    }
+    if (annotation.data.handles?.points) {
+        newAnnotation.data.handles.points = annotation.data.handles.points.map((point) => [...point]);
+    }
+    return newAnnotation;
+}
+export function copyContourSegment(segmentationId, segmentIndex, targetSegmentationId, targetSegmentIndex) {
+    const annotationUIDsMap = getAnnotationsUIDMapFromSegmentation(segmentationId);
+    const targetAnnotationUIDsMap = getAnnotationsUIDMapFromSegmentation(targetSegmentationId);
+    if (!annotationUIDsMap || !targetAnnotationUIDsMap) {
+        return;
+    }
+    if (!annotationUIDsMap?.has(segmentIndex)) {
+        return;
+    }
+    const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+    const viewport = getViewportAssociatedToSegmentation(targetSegmentationId);
+    if (!viewport) {
+        return;
+    }
+    const toolGroup = getToolGroupForViewport(viewport.id);
+    const copyContourAnnotation = (annotation) => {
+        const newAnnotation = copyAnnotation(annotation, targetSegmentationId, targetSegmentIndex);
+        if (toolGroup) {
+            const instance = toolGroup.getToolInstance(annotation.metadata.toolName);
+            if (instance) {
+                if (typeof instance.isSplineAnnotation === 'function' &&
+                    instance.isSplineAnnotation(annotation)) {
+                    instance.createSplineObjectFromType(newAnnotation, annotation.data.spline.type);
+                }
+            }
+        }
+        addAnnotation(newAnnotation, viewport.element);
+        newAnnotationsUID.add(newAnnotation.annotationUID);
+        return newAnnotation;
+    };
+    const newAnnotationsUID = new Set();
+    for (const annotationUID of annotationUIDs) {
+        const annotation = getAnnotation(annotationUID);
+        const newAnnotation = copyContourAnnotation(annotation);
+        if (annotation?.childAnnotationUIDs) {
+            newAnnotation.childAnnotationUIDs = [];
+            for (const childAnnotationUID of annotation.childAnnotationUIDs) {
+                const childAnnotation = getAnnotation(childAnnotationUID);
+                const newChildAnnotation = copyContourAnnotation(childAnnotation);
+                newChildAnnotation.parentAnnotationUID = newAnnotation.annotationUID;
+                newAnnotation.childAnnotationUIDs.push(newChildAnnotation.annotationUID);
+            }
+        }
+    }
+    targetAnnotationUIDsMap.set(targetSegmentIndex, newAnnotationsUID);
+}

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

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

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

@@ -0,0 +1,20 @@
+export function getViewReferenceFromAnnotation(annotation) {
+    const { metadata } = annotation;
+    if (!metadata) {
+        return {};
+    }
+    const { FrameOfReferenceUID, referencedImageId, referencedImageURI, multiSliceReference, cameraFocalPoint, viewPlaneNormal, viewUp, sliceIndex, volumeId, bounds, } = metadata;
+    const viewReference = {
+        FrameOfReferenceUID,
+        referencedImageId,
+        referencedImageURI,
+        multiSliceReference,
+        cameraFocalPoint,
+        viewPlaneNormal,
+        viewUp,
+        sliceIndex,
+        volumeId,
+        bounds,
+    };
+    return viewReference;
+}

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

@@ -1,6 +1,7 @@
 import areSameSegment from './areSameSegment';
 import convertContourSegmentationAnnotation from './convertContourSegmentation';
-import { addition, subtraction } from './logicalOperators';
+import { copyAnnotation, copyContourSegment } from './copyAnnotation';
+export * from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
@@ -8,5 +9,8 @@ export { findAllIntersectingContours } from './getIntersectingAnnotations';
 export { processMultipleIntersections } from './mergeMultipleAnnotations';
 export { contourSegmentationOperation } from './contourSegmentationOperation';
 export * from './sharedOperations';
-export { addition, subtraction, areSameSegment, convertContourSegmentationAnnotation, };
-export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';
+export { areSameSegment, convertContourSegmentationAnnotation, copyContourSegment, copyAnnotation, };
+export * from './polylineUnify';
+export * from './polylineSubtract';
+export * from './polylineIntersect';
+export * from './polylineXor';

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

@@ -1,6 +1,7 @@
 import areSameSegment from './areSameSegment';
 import convertContourSegmentationAnnotation from './convertContourSegmentation';
-import { addition, subtraction } from './logicalOperators';
+import { copyAnnotation, copyContourSegment } from './copyAnnotation';
+export * from './logicalOperators';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
 export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
@@ -8,5 +9,8 @@ export { findAllIntersectingContours } from './getIntersectingAnnotations';
 export { processMultipleIntersections } from './mergeMultipleAnnotations';
 export { contourSegmentationOperation } from './contourSegmentationOperation';
 export * from './sharedOperations';
-export { addition, subtraction, areSameSegment, convertContourSegmentationAnnotation, };
-export { unifyPolylineSets, unifyMultiplePolylineSets, unifyAnnotationPolylines, subtractPolylineSets, subtractMultiplePolylineSets, subtractAnnotationPolylines, } from './unifyPolylineSets';
+export { areSameSegment, convertContourSegmentationAnnotation, copyContourSegment, copyAnnotation, };
+export * from './polylineUnify';
+export * from './polylineSubtract';
+export * from './polylineIntersect';
+export * from './polylineXor';

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

@@ -1,12 +1,21 @@
-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;
+export type SegmentInfo = {
+    segmentationId: string;
+    segmentIndex: number;
+    label?: string;
+    color?: string;
+};
+export type OperatorOptions = SegmentInfo;
+export declare enum LogicalOperation {
+    Union = 0,
+    Subtract = 1,
+    Intersect = 2,
+    XOR = 3,
+    Copy = 4,
+    Delete = 5
+}
+export declare function add(segment1: SegmentInfo, segment2: SegmentInfo, options: OperatorOptions): void;
+export declare function subtract(segment1: SegmentInfo, segment2: SegmentInfo, options: OperatorOptions): void;
+export declare function intersect(segment1: SegmentInfo, segment2: SegmentInfo, options: OperatorOptions): void;
+export declare function xor(segment1: SegmentInfo, segment2: SegmentInfo, options: OperatorOptions): void;
+export declare function copy(segment: SegmentInfo, options: OperatorOptions): void;
+export declare function deleteOperation(segment: SegmentInfo): void;

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[];