@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/utilities/cine/events.js

@@ -4,4 +4,3 @@ var Events;
     Events["CLIP_STARTED"] = "CORNERSTONE_CINE_TOOL_STARTED";
 })(Events || (Events = {}));
 export default Events;
-//# sourceMappingURL=events.js.map

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

@@ -2,4 +2,3 @@ import { playClip, stopClip } from './playClip';
 import Events from './events';
 import { getToolState, addToolState } from './state';
 export { playClip, stopClip, Events, getToolState, addToolState };
-//# sourceMappingURL=index.js.map

package/dist/esm/utilities/cine/playClip.d.ts

@@ -1,4 +1,8 @@
-import { CINETypes } from '../../types';
+import type { CINETypes } from '../../types';
+type StopClipOptions = {
+    stopDynamicCine: boolean;
+    viewportId?: string;
+};
 declare function playClip(element: HTMLDivElement, playClipOptions: CINETypes.PlayClipOptions): void;
-declare function stopClip(element: HTMLDivElement): void;
+declare function stopClip(element: HTMLDivElement, options?: StopClipOptions): void;
 export { playClip, stopClip };

package/dist/esm/utilities/cine/playClip.js

@@ -1,12 +1,11 @@
 import { glMatrix, vec3 } from 'gl-matrix';
-import { utilities as csUtils, getEnabledElement, StackViewport, VolumeViewport, cache, BaseVolumeViewport, Enums, } from '@cornerstonejs/core';
+import { utilities as csUtils, getEnabledElement, StackViewport, VideoViewport, VolumeViewport, cache, BaseVolumeViewport, Enums, } from '@cornerstonejs/core';
 import CINE_EVENTS from './events';
-import { addToolState, getToolState } from './state';
+import { addToolState, getToolState, getToolStateByViewportId } from './state';
 import scroll from '../scroll';
 const { ViewportStatus } = Enums;
 const { triggerEvent } = csUtils;
 const debounced = true;
-const loop = true;
 const dynamicVolumesPlayingMap = new Map();
 function playClip(element, playClipOptions) {
     let playClipTimeouts;
@@ -18,6 +17,9 @@ function playClip(element, playClipOptions) {
     if (!enabledElement) {
         throw new Error('playClip: element must be a valid Cornerstone enabled element');
     }
+    if (!playClipOptions) {
+        playClipOptions = {};
+    }
     playClipOptions.dynamicCineEnabled =
         playClipOptions.dynamicCineEnabled ?? true;
     const { viewport } = enabledElement;
@@ -43,7 +45,10 @@ function playClip(element, playClipOptions) {
         addToolState(element, playClipData);
     }
     else {
-        _stopClip(element, isDynamicCinePlaying);
+        _stopClip(element, {
+            stopDynamicCine: !isDynamicCinePlaying,
+            viewportId: viewport.id,
+        });
     }
     playClipData.dynamicCineEnabled = playClipOptions.dynamicCineEnabled;
     if (playClipOptions.framesPerSecond < 0 ||
@@ -64,8 +69,11 @@ function playClip(element, playClipOptions) {
         const { numScrollSteps, currentStepIndex } = playClipContext;
         let newStepIndex = currentStepIndex + (playClipData.reverse ? -1 : 1);
         const newStepIndexOutOfRange = newStepIndex < 0 || newStepIndex >= numScrollSteps;
-        if (!loop && newStepIndexOutOfRange) {
-            _stopClip(element, isDynamicCinePlaying);
+        if (!playClipData.loop && newStepIndexOutOfRange) {
+            _stopClip(element, {
+                stopDynamicCine: !isDynamicCinePlaying,
+                viewportId: viewport.id,
+            });
             const eventDetail = { element };
             triggerEvent(element, CINE_EVENTS.CLIP_STOPPED, eventDetail);
             return;
@@ -78,13 +86,24 @@ function playClip(element, playClipOptions) {
         }
         const delta = newStepIndex - currentStepIndex;
         if (delta) {
-            playClipContext.scroll(delta);
+            try {
+                playClipContext.scroll(delta);
+            }
+            catch (e) {
+                console.warn('Play clip not scrolling', e);
+                _stopClipWithData(playClipData);
+                triggerEvent(element, CINE_EVENTS.CLIP_STOPPED, eventDetail);
+                return;
+            }
         }
     };
     if (isDynamicCinePlaying) {
         dynamicVolumesPlayingMap.set(volume.volumeId, element);
     }
-    if (playClipTimeouts &&
+    if (playClipContext.play) {
+        playClipData.framesPerSecond = playClipContext.play(playClipOptions.framesPerSecond);
+    }
+    else if (playClipTimeouts &&
         playClipTimeouts.length > 0 &&
         playClipIsTimeVarying) {
         playClipData.usingFrameTimeVector = true;
@@ -102,20 +121,36 @@ function playClip(element, playClipOptions) {
     };
     triggerEvent(element, CINE_EVENTS.CLIP_STARTED, eventDetail);
 }
-function stopClip(element) {
-    _stopClip(element, true);
+function stopClip(element, options = {}) {
+    _stopClip(element, {
+        stopDynamicCine: true,
+        ...options,
+    });
 }
-function _stopClip(element, stopDynamicCine) {
+function _stopClip(element, options = { stopDynamicCine: true, viewportId: undefined }) {
+    const { stopDynamicCine, viewportId } = options;
     const enabledElement = getEnabledElement(element);
+    let toolState;
+    const viewport = enabledElement?.viewport;
     if (!enabledElement) {
-        return;
+        if (viewportId) {
+            toolState = getToolStateByViewportId(viewportId);
+        }
+        else {
+            return;
+        }
     }
-    const { viewport } = enabledElement;
-    const cineToolData = getToolState(viewport.element);
-    if (cineToolData) {
-        _stopClipWithData(cineToolData);
+    else {
+        const { viewport } = enabledElement;
+        toolState = getToolState(viewport.element);
+    }
+    if (toolState) {
+        _stopClipWithData(toolState);
     }
-    if (stopDynamicCine && viewport instanceof BaseVolumeViewport) {
+    if (viewport instanceof VideoViewport) {
+        viewport.pause();
+    }
+    else if (stopDynamicCine && viewport instanceof BaseVolumeViewport) {
         _stopDynamicVolumeCine(element);
     }
 }
@@ -178,7 +213,7 @@ function _stopClipWithData(playClipData) {
 function _getVolumesFromViewport(viewport) {
     return viewport
         .getActors()
-        .map((actor) => cache.getVolume(actor.uid))
+        .map((actor) => cache.getVolume(viewport.getVolumeId()))
         .filter((volume) => !!volume);
 }
 function _getVolumeFromViewport(viewport) {
@@ -210,6 +245,36 @@ function _createStackViewportCinePlayContext(viewport, waitForRendered) {
         },
     };
 }
+function _createVideoViewportCinePlayContext(viewport, waitForRendered) {
+    return {
+        get numScrollSteps() {
+            return viewport.getNumberOfSlices();
+        },
+        get currentStepIndex() {
+            return viewport.getSliceIndex();
+        },
+        get frameTimeVectorEnabled() {
+            return true;
+        },
+        waitForRenderedCount: 0,
+        scroll(delta) {
+            if (this.waitForRenderedCount <= waitForRendered &&
+                viewport.viewportStatus !== ViewportStatus.RENDERED) {
+                this.waitForRenderedCount++;
+                return;
+            }
+            this.waitForRenderedCount = 0;
+            scroll(viewport, { delta, debounceLoading: debounced });
+        },
+        play(fps) {
+            if (fps) {
+                viewport.setPlaybackRate(fps / 24);
+            }
+            viewport.play();
+            return viewport.getFrameRate();
+        },
+    };
+}
 function _createVolumeViewportCinePlayContext(viewport, volume) {
     const { volumeId } = volume;
     const cachedScrollInfo = {
@@ -260,7 +325,7 @@ function _createDynamicVolumeViewportCinePlayContext(volume) {
             return false;
         },
         scroll(delta) {
-            volume.timePointIndex += delta;
+            volume.scroll(delta);
         },
     };
 }
@@ -275,7 +340,9 @@ function _createCinePlayContext(viewport, playClipOptions) {
         }
         return _createVolumeViewportCinePlayContext(viewport, volume);
     }
+    if (viewport instanceof VideoViewport) {
+        return _createVideoViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
+    }
     throw new Error('Unknown viewport type');
 }
 export { playClip, stopClip };
-//# sourceMappingURL=playClip.js.map

package/dist/esm/utilities/cine/state.d.ts

@@ -1,4 +1,5 @@
-import { CINETypes } from '../../types';
+import type { CINETypes } from '../../types';
 declare function addToolState(element: HTMLDivElement, data: CINETypes.ToolData): void;
 declare function getToolState(element: HTMLDivElement): CINETypes.ToolData | undefined;
-export { addToolState, getToolState };
+declare function getToolStateByViewportId(viewportId: string): CINETypes.ToolData | undefined;
+export { addToolState, getToolState, getToolStateByViewportId };

package/dist/esm/utilities/cine/state.js

@@ -10,5 +10,7 @@ function getToolState(element) {
     const { viewportId } = enabledElement;
     return state[viewportId];
 }
-export { addToolState, getToolState };
-//# sourceMappingURL=state.js.map
+function getToolStateByViewportId(viewportId) {
+    return state[viewportId];
+}
+export { addToolState, getToolState, getToolStateByViewportId };

package/dist/esm/utilities/clip.js

@@ -6,4 +6,3 @@ export function clipToBox(point, box) {
     point.y = clip(point.y, 0, box.height);
 }
 export default clip;
-//# sourceMappingURL=clip.js.map

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

@@ -0,0 +1,2 @@
+import type { ContourSegmentationAnnotation } from '../../types';
+export declare function addContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): void;

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

@@ -0,0 +1,21 @@
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+export function addContourSegmentationAnnotation(annotation) {
+    if (annotation.parentAnnotationUID) {
+        return;
+    }
+    if (!annotation.data.segmentation) {
+        throw new Error('addContourSegmentationAnnotation: annotation does not have a segmentation data');
+    }
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation.representationData.Contour) {
+        segmentation.representationData.Contour = { annotationUIDsMap: new Map() };
+    }
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
+    let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+    if (!annotationsUIDsSet) {
+        annotationsUIDsSet = new Set();
+        annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+    }
+    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet.add(annotation.annotationUID));
+}

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

@@ -0,0 +1,2 @@
+import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+export default function areSameSegment(firstAnnotation: ContourSegmentationAnnotation, secondAnnotation: ContourSegmentationAnnotation): boolean;

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

@@ -0,0 +1,6 @@
+export default function areSameSegment(firstAnnotation, secondAnnotation) {
+    const { segmentation: firstSegmentation } = firstAnnotation.data;
+    const { segmentation: secondSegmentation } = secondAnnotation.data;
+    return (firstSegmentation.segmentationId === secondSegmentation.segmentationId &&
+        firstSegmentation.segmentIndex === secondSegmentation.segmentIndex);
+}

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

@@ -0,0 +1,4 @@
+export { default as areSameSegment } from './areSameSegment';
+export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';

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

@@ -0,0 +1,4 @@
+export { default as areSameSegment } from './areSameSegment';
+export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';

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

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

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

@@ -0,0 +1,3 @@
+export default function isContourSegmentationAnnotation(annotation) {
+    return !!annotation.data?.segmentation;
+}

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

@@ -0,0 +1,2 @@
+import type { ContourSegmentationAnnotation } from '../../types';
+export declare function removeContourSegmentationAnnotation(annotation: ContourSegmentationAnnotation): void;

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

@@ -0,0 +1,17 @@
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+export function removeContourSegmentationAnnotation(annotation) {
+    if (!annotation.data.segmentation) {
+        throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');
+    }
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
+    const segmentation = getSegmentation(segmentationId);
+    const { annotationUIDsMap } = segmentation?.representationData.Contour || {};
+    const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
+    if (!annotationsUIDsSet) {
+        return;
+    }
+    annotationsUIDsSet.delete(annotation.annotationUID);
+    if (!annotationsUIDsSet.size) {
+        annotationUIDsMap.delete(segmentIndex);
+    }
+}

package/dist/esm/utilities/contours/AnnotationToPointData.d.ts

@@ -0,0 +1,11 @@
+declare class AnnotationToPointData {
+    static TOOL_NAMES: Record<string, unknown>;
+    constructor();
+    static convert(annotation: any, index: any, metadataProvider: any): {
+        ReferencedROINumber: any;
+        ROIDisplayColor: number[];
+        ContourSequence: any;
+    };
+    static register(toolClass: any): void;
+}
+export default AnnotationToPointData;

package/dist/esm/utilities/contours/AnnotationToPointData.js

@@ -0,0 +1,38 @@
+import RectangleROIStartEndThreshold from './RectangleROIStartEndThreshold';
+function validateAnnotation(annotation) {
+    if (!annotation?.data) {
+        throw new Error('Tool data is empty');
+    }
+    if (!annotation.metadata || annotation.metadata.referencedImageId) {
+        throw new Error('Tool data is not associated with any imageId');
+    }
+}
+class AnnotationToPointData {
+    static { this.TOOL_NAMES = {}; }
+    constructor() {
+    }
+    static convert(annotation, index, metadataProvider) {
+        validateAnnotation(annotation);
+        const { toolName } = annotation.metadata;
+        const toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
+        if (!toolClass) {
+            throw new Error(`Unknown tool type: ${toolName}, cannot convert to RTSSReport`);
+        }
+        const ContourSequence = toolClass.getContourSequence(annotation, metadataProvider);
+        const color = [
+            Math.floor(Math.random() * 255),
+            Math.floor(Math.random() * 255),
+            Math.floor(Math.random() * 255),
+        ];
+        return {
+            ReferencedROINumber: index + 1,
+            ROIDisplayColor: color,
+            ContourSequence,
+        };
+    }
+    static register(toolClass) {
+        AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
+    }
+}
+AnnotationToPointData.register(RectangleROIStartEndThreshold);
+export default AnnotationToPointData;

package/dist/esm/utilities/contours/RectangleROIStartEndThreshold.d.ts

@@ -0,0 +1,6 @@
+declare class RectangleROIStartEndThreshold {
+    static toolName: string;
+    constructor();
+    static getContourSequence(toolData: any, metadataProvider: any): any;
+}
+export default RectangleROIStartEndThreshold;

package/dist/esm/utilities/contours/RectangleROIStartEndThreshold.js

@@ -0,0 +1,40 @@
+class RectangleROIStartEndThreshold {
+    constructor() {
+    }
+    static getContourSequence(toolData, metadataProvider) {
+        const { data } = toolData;
+        const { projectionPoints, projectionPointsImageIds } = data.cachedStats;
+        return projectionPoints.map((point, index) => {
+            const ContourData = getPointData(point);
+            const ContourImageSequence = getContourImageSequence(projectionPointsImageIds[index], metadataProvider);
+            return {
+                NumberOfContourPoints: ContourData.length / 3,
+                ContourImageSequence,
+                ContourGeometricType: 'CLOSED_PLANAR',
+                ContourData,
+            };
+        });
+    }
+}
+RectangleROIStartEndThreshold.toolName = 'RectangleROIStartEndThreshold';
+function getPointData(points) {
+    const orderedPoints = [
+        ...points[0],
+        ...points[1],
+        ...points[3],
+        ...points[2],
+    ];
+    const pointsArray = orderedPoints.flat();
+    const pointsArrayWithPrecision = pointsArray.map((point) => {
+        return point.toFixed(2);
+    });
+    return pointsArrayWithPrecision;
+}
+function getContourImageSequence(imageId, metadataProvider) {
+    const sopCommon = metadataProvider.get('sopCommonModule', imageId);
+    return {
+        ReferencedSOPClassUID: sopCommon.sopClassUID,
+        ReferencedSOPInstanceUID: sopCommon.sopInstanceUID,
+    };
+}
+export default RectangleROIStartEndThreshold;

package/dist/esm/utilities/contours/areCoplanarContours.d.ts

@@ -0,0 +1,2 @@
+import type { ContourAnnotation } from '../../types/ContourAnnotation';
+export default function areCoplanarContours(firstAnnotation: ContourAnnotation, secondAnnotation: ContourAnnotation): boolean;

package/dist/esm/utilities/contours/areCoplanarContours.js

@@ -0,0 +1,15 @@
+import { glMatrix, vec3 } from 'gl-matrix';
+export default function areCoplanarContours(firstAnnotation, secondAnnotation) {
+    const { viewPlaneNormal: firstViewPlaneNormal } = firstAnnotation.metadata;
+    const { viewPlaneNormal: secondViewPlaneNormal } = secondAnnotation.metadata;
+    const dot = vec3.dot(firstViewPlaneNormal, secondViewPlaneNormal);
+    const parallelPlanes = glMatrix.equals(1, Math.abs(dot));
+    if (!parallelPlanes) {
+        return false;
+    }
+    const { polyline: firstPolyline } = firstAnnotation.data.contour;
+    const { polyline: secondPolyline } = secondAnnotation.data.contour;
+    const firstDistance = vec3.dot(firstViewPlaneNormal, firstPolyline[0]);
+    const secondDistance = vec3.dot(firstViewPlaneNormal, secondPolyline[0]);
+    return glMatrix.equals(firstDistance, secondDistance);
+}

package/dist/esm/utilities/contours/calculatePerimeter.d.ts

@@ -0,0 +1,2 @@
+declare function calculatePerimeter(polyline: number[][], closed: boolean): number;
+export default calculatePerimeter;

package/dist/esm/utilities/contours/calculatePerimeter.js

@@ -0,0 +1,16 @@
+function calculatePerimeter(polyline, closed) {
+    let perimeter = 0;
+    for (let i = 0; i < polyline.length - 1; i++) {
+        const point1 = polyline[i];
+        const point2 = polyline[i + 1];
+        perimeter += Math.sqrt(Math.pow(point2[0] - point1[0], 2) + Math.pow(point2[1] - point1[1], 2));
+    }
+    if (closed) {
+        const firstPoint = polyline[0];
+        const lastPoint = polyline[polyline.length - 1];
+        perimeter += Math.sqrt(Math.pow(lastPoint[0] - firstPoint[0], 2) +
+            Math.pow(lastPoint[1] - firstPoint[1], 2));
+    }
+    return perimeter;
+}
+export default calculatePerimeter;

package/dist/esm/utilities/contours/contourFinder.d.ts

@@ -0,0 +1,7 @@
+export declare function findContours(lines: any): any;
+export declare function findContoursFromReducedSet(lines: any): any;
+declare const _default: {
+    findContours: typeof findContours;
+    findContoursFromReducedSet: typeof findContoursFromReducedSet;
+};
+export default _default;

package/dist/esm/utilities/contours/contourFinder.js

@@ -0,0 +1,62 @@
+function findNextLink(line, lines, contourPoints) {
+    let index = -1;
+    lines.forEach((cell, i) => {
+        if (index >= 0) {
+            return;
+        }
+        if (cell.a == line.b) {
+            index = i;
+        }
+    });
+    if (index >= 0) {
+        const nextLine = lines[index];
+        lines.splice(index, 1);
+        contourPoints.push(nextLine.b);
+        if (contourPoints[0] == nextLine.b) {
+            return {
+                remainingLines: lines,
+                contourPoints,
+                type: 'CLOSED_PLANAR',
+            };
+        }
+        return findNextLink(nextLine, lines, contourPoints);
+    }
+    return {
+        remainingLines: lines,
+        contourPoints,
+        type: 'OPEN_PLANAR',
+    };
+}
+export function findContours(lines) {
+    if (lines.length == 0) {
+        return [];
+    }
+    const contourPoints = [];
+    const firstCell = lines.shift();
+    contourPoints.push(firstCell.a);
+    contourPoints.push(firstCell.b);
+    const result = findNextLink(firstCell, lines, contourPoints);
+    if (result.remainingLines.length == 0) {
+        return [
+            {
+                type: result.type,
+                contourPoints: result.contourPoints,
+            },
+        ];
+    }
+    else {
+        const extraContours = findContours(result.remainingLines);
+        extraContours.push({
+            type: result.type,
+            contourPoints: result.contourPoints,
+        });
+        return extraContours;
+    }
+}
+export function findContoursFromReducedSet(lines) {
+    return findContours(lines);
+}
+export default {
+    findContours,
+    findContoursFromReducedSet,
+};

package/dist/esm/utilities/contours/detectContourHoles.d.ts

@@ -0,0 +1,5 @@
+export declare function processContourHoles(contours: any, points: any, useXOR?: boolean): any;
+declare const _default: {
+    processContourHoles: typeof processContourHoles;
+};
+export default _default;

package/dist/esm/utilities/contours/detectContourHoles.js

@@ -0,0 +1,73 @@
+const getIsPointInsidePolygon = (point, vertices) => {
+    const x = point[0];
+    const y = point[1];
+    let inside = false;
+    for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
+        const xi = vertices[i][0], yi = vertices[i][1];
+        const xj = vertices[j][0], yj = vertices[j][1];
+        const intersect = yi > y != yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
+        }
+    }
+    return inside;
+};
+function checkEnclosed(outerContour, innerContour, points) {
+    const vertices = [];
+    outerContour.contourPoints.forEach((point) => {
+        vertices.push([points[point][0], points[point][1]]);
+    });
+    let pointsNotEnclosed = 0;
+    innerContour.contourPoints.forEach((point) => {
+        const result = getIsPointInsidePolygon([points[point][0], points[point][1]], vertices);
+        if (!result) {
+            pointsNotEnclosed++;
+        }
+    });
+    return pointsNotEnclosed === 0;
+}
+export function processContourHoles(contours, points, useXOR = true) {
+    const retContours = contours.filter((contour) => contour.type !== 'CLOSED_PLANAR');
+    const closedContours = contours.filter((contour) => contour.type === 'CLOSED_PLANAR');
+    const contourWithHoles = [];
+    let contourWithoutHoles = [];
+    closedContours.forEach((contour, index) => {
+        const holes = [];
+        closedContours.forEach((hContour, hIndex) => {
+            if (index != hIndex) {
+                if (checkEnclosed(contour, hContour, points)) {
+                    holes.push(hIndex);
+                }
+            }
+        });
+        if (holes.length > 0) {
+            contourWithHoles.push({
+                contour,
+                holes,
+            });
+        }
+        else {
+            contourWithoutHoles.push(index);
+        }
+    });
+    if (useXOR) {
+        contourWithHoles.forEach((contourHoleSet) => {
+            contourHoleSet.contour.type = 'CLOSEDPLANAR_XOR';
+            retContours.push(contourHoleSet.contour);
+            contourHoleSet.holes.forEach((holeIndex) => {
+                closedContours[holeIndex].type = 'CLOSEDPLANAR_XOR';
+                retContours.push(closedContours[holeIndex]);
+                contourWithoutHoles = contourWithoutHoles.filter((contourIndex) => {
+                    return contourIndex !== holeIndex;
+                });
+            });
+        });
+        contourWithoutHoles.forEach((contourIndex) => {
+            retContours.push(closedContours[contourIndex]);
+        });
+    }
+    else {
+    }
+    return retContours;
+}
+export default { processContourHoles };

package/dist/esm/utilities/contours/findHandlePolylineIndex.d.ts

@@ -0,0 +1,2 @@
+import type { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+export default function findHandlePolylineIndex(annotation: ContourAnnotation, handleIndex: number): number;

package/dist/esm/utilities/contours/findHandlePolylineIndex.js

@@ -0,0 +1,31 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+const { isEqual } = csUtils;
+export default function findHandlePolylineIndex(annotation, handleIndex) {
+    const { polyline } = annotation.data.contour;
+    const { points } = annotation.data.handles;
+    const { length } = points;
+    if (handleIndex === length) {
+        return polyline.length;
+    }
+    if (handleIndex < 0) {
+        handleIndex = (handleIndex + length) % length;
+    }
+    if (handleIndex === 0) {
+        return 0;
+    }
+    const handle = points[handleIndex];
+    const index = polyline.findIndex((point) => isEqual(handle, point));
+    if (index !== -1) {
+        return index;
+    }
+    let closestDistance = Infinity;
+    return polyline.reduce((closestIndex, point, testIndex) => {
+        const distance = vec3.squaredDistance(point, handle);
+        if (distance < closestDistance) {
+            closestDistance = distance;
+            return testIndex;
+        }
+        return closestIndex;
+    }, -1);
+}

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.d.ts

@@ -0,0 +1,4 @@
+declare function generateContourSetsFromLabelmap({ segmentations }: {
+    segmentations: any;
+}): any[];
+export { generateContourSetsFromLabelmap };