@cornerstonejs/tools 3.24.0 → 3.25.0

package/dist/esm/stateManagement/segmentation/utilities/convertContourHoles.d.ts

@@ -0,0 +1 @@
+export default function convertContourHoles(segmentationId: string, segmentIndex: number, targetSegmentationId?: string, targetSegmentationIndex?: number): void;

package/dist/esm/stateManagement/segmentation/utilities/convertContourHoles.js

@@ -0,0 +1,66 @@
+import { findContourHoles } from '../../../utilities/contours';
+import { getAnnotation, clearParentAnnotation, } from '../../annotation/annotationState';
+import { getSegmentation } from '../getSegmentation';
+import { extractSegmentPolylines } from './extractSegmentPolylines';
+export default function convertContourHoles(segmentationId, segmentIndex, targetSegmentationId, targetSegmentationIndex) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
+        return;
+    }
+    if (!segmentation.representationData.Contour) {
+        console.warn(`No contour representation found for segmentation ${segmentationId}`);
+        return;
+    }
+    const { annotationUIDsMap } = segmentation?.representationData.Contour || {};
+    if (!annotationUIDsMap) {
+        console.warn(`No annotation map found for segmentation ${segmentationId}`);
+        return;
+    }
+    const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
+    if (!annotationsUIDsSet) {
+        console.warn(`Segmentation index ${segmentIndex} has no annotations in segmentation ${segmentationId}`);
+        return;
+    }
+    let targetUIDsSet;
+    if (targetSegmentationId && typeof targetSegmentationIndex === 'number') {
+        const targetSegmentation = getSegmentation(targetSegmentationId);
+        if (!targetSegmentation) {
+            console.warn(`Target segmentation ${targetSegmentationId} does not exist.`);
+            return;
+        }
+        if (!targetSegmentation.representationData.Contour) {
+            console.warn(`No contour representation found for target segmentation ${targetSegmentationId}`);
+            return;
+        }
+        targetUIDsSet =
+            targetSegmentation.representationData.Contour.annotationUIDsMap.get(targetSegmentationIndex);
+        if (!targetUIDsSet) {
+            targetUIDsSet = new Set();
+            targetSegmentation.representationData.Contour.annotationUIDsMap.set(targetSegmentationIndex, targetUIDsSet);
+        }
+    }
+    const polylinesCanvasMap = extractSegmentPolylines(segmentationId, segmentIndex);
+    if (!polylinesCanvasMap) {
+        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
+        return;
+    }
+    const keys = Array.from(polylinesCanvasMap?.keys());
+    const polylines = keys.map((key) => polylinesCanvasMap.get(key));
+    const holeDetectionResults = findContourHoles(polylines);
+    if (holeDetectionResults?.length > 0) {
+        holeDetectionResults.forEach((hole) => {
+            hole.holeIndexes.forEach((index) => {
+                const annotation = getAnnotation(keys[index]);
+                clearParentAnnotation(annotation);
+                if (targetSegmentationId &&
+                    typeof targetSegmentationIndex === 'number') {
+                    targetUIDsSet.add(annotation.annotationUID);
+                }
+                else {
+                    annotationsUIDsSet.add(annotation.annotationUID);
+                }
+            });
+        });
+    }
+}

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.d.ts

@@ -0,0 +1 @@
+export declare function getAnnotationsUIDMapFromSegmentation(segmentationId: string): Map<number, Set<string>>;

package/dist/esm/stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.js

@@ -0,0 +1,17 @@
+import { getSegmentation } from '../getSegmentation';
+export function getAnnotationsUIDMapFromSegmentation(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        ?.Contour;
+    if (!contourRepresentationData) {
+        return;
+    }
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    return annotationUIDsMap;
+}

package/dist/esm/stateManagement/segmentation/utilities/index.d.ts

@@ -1,4 +1,5 @@
 export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
 export { default as decimateContours } from './decimateContours';
 export { extractSegmentPolylines } from './extractSegmentPolylines';
@@ -6,3 +7,4 @@ export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotati
 export { default as removeContourHoles } from './removeContourHoles';
 export { default as removeContourIslands } from './removeContourIslands';
 export { default as smoothContours } from './smoothContours';
+export { default as convertContourHoles } from './convertContourHoles';

package/dist/esm/stateManagement/segmentation/utilities/index.js

@@ -1,4 +1,6 @@
+import { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getViewportAssociatedToSegmentation, getViewportWithMatchingViewPlaneNormal, } from './getViewportAssociatedToSegmentation';
+export { getAnnotationsUIDMapFromSegmentation } from './getAnnotationsUIDMapFromSegmentation';
 export { getAnnotationMapFromSegmentation } from './getAnnotationMapFromSegmentation';
 export { default as decimateContours } from './decimateContours';
 export { extractSegmentPolylines } from './extractSegmentPolylines';
@@ -6,3 +8,4 @@ export { removeCompleteContourAnnotation } from './removeCompleteContourAnnotati
 export { default as removeContourHoles } from './removeContourHoles';
 export { default as removeContourIslands } from './removeContourIslands';
 export { default as smoothContours } from './smoothContours';
+export { default as convertContourHoles } from './convertContourHoles';

package/dist/esm/stateManagement/segmentation/utilities/removeContourHoles.js

@@ -1,6 +1,5 @@
 import { findContourHoles } from '../../../utilities/contours';
 import { getAnnotation } from '../../annotation/annotationState';
-import { triggerAnnotationRemoved } from '../../annotation/helpers/state';
 import { getSegmentation } from '../getSegmentation';
 import { extractSegmentPolylines } from './extractSegmentPolylines';
 import { removeCompleteContourAnnotation } from './removeCompleteContourAnnotation';

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -64,6 +64,8 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     protected isContourSegmentationTool(): boolean;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     protected createInterpolatedSplineControl(annotation: any): void;
+    isSplineAnnotation(annotation: ContourAnnotation): boolean;
+    createSplineObjectFromType(annotation: ContourAnnotation, splineType: string): void;
     protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     private _renderStats;
     addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;

package/dist/esm/tools/annotation/SplineROITool.js

@@ -41,6 +41,12 @@ var SplineToolActions;
     SplineToolActions["AddControlPoint"] = "addControlPoint";
     SplineToolActions["DeleteControlPoint"] = "deleteControlPoint";
 })(SplineToolActions || (SplineToolActions = {}));
+const splineToolNames = [
+    'CatmullRomSplineROI',
+    'LinearSplineROI',
+    'BSplineROI',
+    'CardinalSplineROI',
+];
 class SplineROITool extends ContourSegmentationBaseTool {
     static { this.toolName = 'SplineROI'; }
     static { this.SplineTypes = SplineTypesEnum; }
@@ -684,6 +690,18 @@ class SplineROITool extends ContourSegmentationBaseTool {
         }
         points.push(polyline[polyline.length - 1]);
     }
+    isSplineAnnotation(annotation) {
+        return splineToolNames.includes(annotation?.metadata?.toolName);
+    }
+    createSplineObjectFromType(annotation, splineType) {
+        const splineConfig = this._getSplineConfig(splineType);
+        const spline = new splineConfig.Class();
+        annotation.data.spline = {
+            type: splineConfig.type,
+            instance: spline,
+            resolution: splineConfig.resolution,
+        };
+    }
     createAnnotation(evt) {
         const contourAnnotation = super.createAnnotation(evt);
         const { world: worldPos } = evt.detail.currentPoints;

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;