@ohif/app 3.12.0-beta.67 → 3.12.0-beta.69

package/dist/{9892.bundle.34f911ad728a17a0ad60.js → 9892.bundle.7a23896727af274e8c43.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9892,2345],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9892,5400],{
 
 /***/ 5057:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -6042,7 +6042,8 @@ function toWindowLevel(low, high) {
     return { windowWidth, windowCenter };
 }
 function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR) {
-    if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR) {
+    if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR ||
+        voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.SAMPLED_SIGMOID) {
         return {
             lower: windowCenter - 0.5 - (windowWidth - 1) / 2,
             upper: windowCenter - 0.5 + (windowWidth - 1) / 2,
@@ -6054,14 +6055,6 @@ function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILU
             upper: windowCenter + windowWidth / 2,
         };
     }
-    else if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.SAMPLED_SIGMOID) {
-        const xLower = (0,_logit__WEBPACK_IMPORTED_MODULE_1__/* .logit */ .i)(0.01, windowCenter, windowWidth);
-        const xUpper = (0,_logit__WEBPACK_IMPORTED_MODULE_1__/* .logit */ .i)(0.99, windowCenter, windowWidth);
-        return {
-            lower: xLower,
-            upper: xUpper,
-        };
-    }
     else {
         throw new Error('Invalid VOI LUT function');
     }
@@ -6925,7 +6918,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.5.5';
+const version = '4.5.19';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 
@@ -9744,8 +9737,8 @@ var cursors = __webpack_require__(79475);
 var types = __webpack_require__(13369);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/index.js + 1 modules
 var annotation = __webpack_require__(47807);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 19 modules
-var stateManagement_segmentation = __webpack_require__(83673);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 9 modules
+var stateManagement_segmentation = __webpack_require__(55126);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/splines/Spline.js
 
 class Spline_Spline {
@@ -13901,6 +13894,7 @@ var MatrixBuilder = __webpack_require__(89265);
 
 
 
+
 const { RENDERING_DEFAULTS: CrosshairsTool_RENDERING_DEFAULTS } = esm.CONSTANTS;
 function CrosshairsTool_defaultReferenceLineColor() {
     return 'rgb(0, 200, 0)';
@@ -15070,9 +15064,42 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
         });
     }
     setToolCenter(toolCenter, suppressEvents = false) {
-        this.toolCenter = toolCenter;
         const viewportsInfo = this._getViewportsInfo();
-        (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportsInfo.map(({ viewportId }) => viewportId));
+        viewportsInfo.map(({ renderingEngineId, viewportId }) => {
+            const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
+            const viewport = renderingEngine.getViewport(viewportId);
+            const camera = viewport.getCamera();
+            const { focalPoint, position, viewPlaneNormal } = camera;
+            const delta = [
+                toolCenter[0] - focalPoint[0],
+                toolCenter[1] - focalPoint[1],
+                toolCenter[2] - focalPoint[2],
+            ];
+            const scroll = delta[0] * viewPlaneNormal[0] +
+                delta[1] * viewPlaneNormal[1] +
+                delta[2] * viewPlaneNormal[2];
+            const scrollDelta = [
+                scroll * viewPlaneNormal[0],
+                scroll * viewPlaneNormal[1],
+                scroll * viewPlaneNormal[2],
+            ];
+            const newFocalPoint = [
+                focalPoint[0] + scrollDelta[0],
+                focalPoint[1] + scrollDelta[1],
+                focalPoint[2] + scrollDelta[2],
+            ];
+            const newPosition = [
+                position[0] + scrollDelta[0],
+                position[1] + scrollDelta[1],
+                position[2] + scrollDelta[2],
+            ];
+            viewport.setCamera({
+                focalPoint: newFocalPoint,
+                position: newPosition,
+            });
+            viewport.render();
+        });
+        this.toolCenter = toolCenter;
         if (!suppressEvents) {
             (0,esm.triggerEvent)(esm.eventTarget, enums.Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
                 toolGroupId: this.toolGroupId,
@@ -15469,6 +15496,11 @@ class MagnifyTool extends base/* BaseTool */.oS {
             magnifyToolElement.style.display = 'block';
             (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         };
+        this._cancelCallback = (evt) => {
+            evt.preventDefault();
+            evt.stopPropagation();
+            this._dragEndCallback(evt);
+        };
         this._dragCallback = (evt) => {
             const eventDetail = evt.detail;
             const { deltaPoints, element, currentPoints } = eventDetail;
@@ -15501,7 +15533,12 @@ class MagnifyTool extends base/* BaseTool */.oS {
             magnifyViewport.render();
         };
         this._dragEndCallback = (evt) => {
-            const { element } = evt.detail;
+            let { element } = evt.detail;
+            if (element === undefined) {
+                const { enabledElement } = this.editData;
+                const { viewport } = enabledElement;
+                element = viewport.element;
+            }
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             renderingEngine.disableElement(MAGNIFY_VIEWPORT_ID);
@@ -15518,6 +15555,7 @@ class MagnifyTool extends base/* BaseTool */.oS {
             element.addEventListener(enums.Events.MOUSE_UP, this._dragEndCallback);
             element.addEventListener(enums.Events.MOUSE_DRAG, this._dragCallback);
             element.addEventListener(enums.Events.MOUSE_CLICK, this._dragEndCallback);
+            element.addEventListener('contextmenu', this._cancelCallback);
             element.addEventListener(enums.Events.TOUCH_END, this._dragEndCallback);
             element.addEventListener(enums.Events.TOUCH_DRAG, this._dragCallback);
         };
@@ -15526,6 +15564,7 @@ class MagnifyTool extends base/* BaseTool */.oS {
             element.removeEventListener(enums.Events.MOUSE_UP, this._dragEndCallback);
             element.removeEventListener(enums.Events.MOUSE_DRAG, this._dragCallback);
             element.removeEventListener(enums.Events.MOUSE_CLICK, this._dragEndCallback);
+            element.removeEventListener('contextmenu', this._cancelCallback);
             element.removeEventListener(enums.Events.TOUCH_END, this._dragEndCallback);
             element.removeEventListener(enums.Events.TOUCH_DRAG, this._dragCallback);
         };
@@ -23228,6 +23267,7 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
     }) {
         super(toolProps, defaultToolProps);
         this.addNewAnnotation = (evt) => {
+            this.startGroupRecording();
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
@@ -23326,6 +23366,8 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
                     (0,helpers_state.triggerAnnotationCompleted)(annotation);
                     this.createMemo(element, annotation, { newAnnotation: !!this.memo });
                     setAnnotationLabel(annotation, element, label);
+                    this.endGroupRecording();
+                    this.doneEditMemo();
                     (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
                 });
             }
@@ -33332,7 +33374,7 @@ async function computeVolumeLabelmapFromStack(args) {
 
 /***/ }),
 
-/***/ 83673:
+/***/ 55126:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -33512,389 +33554,16 @@ function hasCustomStyle(specifier) {
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentIndex.js
 var segmentIndex = __webpack_require__(70930);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/getAnnotationsUIDMapFromSegmentation.js
-var utilities_getAnnotationsUIDMapFromSegmentation = __webpack_require__(98484);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/getViewportAssociatedToSegmentation.js
-var getViewportAssociatedToSegmentation = __webpack_require__(16493);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
-var annotationState = __webpack_require__(82056);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/getAnnotationMapFromSegmentation.js
-
-function getAnnotationMapFromSegmentation_getAnnotationMapFromSegmentation(contourRepresentationData, options = {}) {
-    const annotationMap = contourRepresentationData.annotationUIDsMap;
-    const segmentIndices = options.segmentIndices?.length
-        ? options.segmentIndices
-        : Array.from(annotationMap.keys());
-    const annotationUIDsInSegmentMap = new Map();
-    segmentIndices.forEach((index) => {
-        const annotationUIDsInSegment = annotationMap.get(index);
-        let uids = Array.from(annotationUIDsInSegment);
-        uids = uids.filter((uid) => !getAnnotation(uid).parentAnnotationUID);
-        const annotations = uids.map((uid) => {
-            const annotation = getAnnotation(uid);
-            const hasChildAnnotations = annotation.childAnnotationUIDs?.length;
-            const childPolylinesInformation = hasChildAnnotations &&
-                annotation.childAnnotationUIDs.map((childUID) => {
-                    const childAnnotation = getAnnotation(childUID);
-                    return {
-                        polyline: childAnnotation.data.contour.polyline,
-                        isClosed: childAnnotation.data.contour.closed,
-                    };
-                });
-            const holesClosed = hasChildAnnotations &&
-                childPolylinesInformation.map((childInfo) => childInfo.isClosed);
-            const childPolylines = hasChildAnnotations &&
-                childPolylinesInformation.map((childInfo) => childInfo.polyline);
-            return {
-                polyline: annotation.data.contour.polyline,
-                isClosed: annotation.data.contour.closed,
-                annotationUID: annotation.annotationUID,
-                referencedImageId: annotation.metadata.referencedImageId,
-                holesPolyline: childPolylines,
-                holesUIDs: annotation.childAnnotationUIDs,
-                holesClosed,
-            };
-        });
-        annotationUIDsInSegmentMap.set(index, annotations);
-    });
-    return { segmentIndices, annotationUIDsInSegmentMap };
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
-var segmentation_getSegmentation = __webpack_require__(33283);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/index.js + 1 modules
-var contourSegmentation = __webpack_require__(56534);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/getPolylineMap.js
-
-function closePolyline(polyline, closed) {
-    if (!polyline || polyline.length === 0) {
-        return [];
-    }
-    if (!closed) {
-        return [...polyline];
-    }
-    const firstPoint = polyline[0];
-    const lastPoint = polyline[polyline.length - 1];
-    const isAlreadyClosed = firstPoint[0] === lastPoint[0] &&
-        firstPoint[1] === lastPoint[1] &&
-        firstPoint[2] === lastPoint[2];
-    if (isAlreadyClosed) {
-        return [...polyline];
-    }
-    return [...polyline, firstPoint];
-}
-function getPolylineMap_getPolylinesMap(contourRepresentationData, segmentIndex) {
-    const { annotationUIDsInSegmentMap } = getAnnotationMapFromSegmentation(contourRepresentationData);
-    if (!annotationUIDsInSegmentMap.has(segmentIndex)) {
-        console.warn(`No contour information found for segmentIndex ${segmentIndex}`);
-        return;
-    }
-    const polylines = new Map();
-    const annotationsInfo = annotationUIDsInSegmentMap.get(segmentIndex);
-    for (const annotationInfo of annotationsInfo) {
-        polylines.set(annotationInfo.annotationUID, closePolyline(annotationInfo.polyline, annotationInfo.isClosed));
-        for (let i = 0; i < annotationInfo.holesUIDs?.length; i++) {
-            polylines.set(annotationInfo.holesUIDs[i], closePolyline(annotationInfo.holesPolyline[i], annotationInfo.holesClosed[i]));
-        }
-    }
-    return polylines;
-}
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/extractSegmentPolylines.js
-
-
-
-
-
-function extractSegmentPolylines_extractSegmentPolylines(segmentationId, segmentIndex) {
-    const viewports = getViewportsAssociatedToSegmentation(segmentationId);
-    const segmentation = getSegmentation(segmentationId);
-    if (!segmentation) {
-        return;
-    }
-    if (!segmentation.representationData.Contour) {
-        return;
-    }
-    const contourRepresentationData = segmentation.representationData
-        .Contour;
-    const { annotationUIDsMap } = contourRepresentationData;
-    if (!annotationUIDsMap) {
-        return;
-    }
-    if (!annotationUIDsMap.get(segmentIndex)) {
-        return;
-    }
-    const polyLinesMap = getPolylinesMap(contourRepresentationData, segmentIndex);
-    if (!polyLinesMap) {
-        return;
-    }
-    const keys = Array.from(polyLinesMap?.keys());
-    const polylinesCanvasMap = new Map();
-    for (const key of keys) {
-        const annotation = getAnnotation(key);
-        const viewport = getViewportWithMatchingViewPlaneNormal(viewports, annotation);
-        polylinesCanvasMap.set(key, convertContourPolylineToCanvasSpace(polyLinesMap.get(key), viewport));
-    }
-    return polylinesCanvasMap;
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/polyline/decimate.js
-var polyline_decimate = __webpack_require__(99944);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/decimateContours.js
-
-
-
-
-
-function decimateContours(segmentationId, segmentIndex, options = { epsilon: 0.1 }) {
-    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 viewports = getViewportsAssociatedToSegmentation(segmentationId);
-    if (!viewports) {
-        console.warn('No viewport associated to the segmentation found');
-        return;
-    }
-    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());
-    for (const annotationUID of keys) {
-        const annotation = getAnnotation(annotationUID);
-        if (!annotation) {
-            continue;
-        }
-        const polylineCanvas = polylinesCanvasMap.get(annotationUID);
-        const decimatedPolyline2D = decimate(polylineCanvas, options.epsilon);
-        const viewport = getViewportWithMatchingViewPlaneNormal(viewports, annotation);
-        if (viewport) {
-            annotation.data.contour.polyline = decimatedPolyline2D.map((point2D) => viewport.canvasToWorld(point2D));
-            invalidateAnnotation(annotation);
-        }
-    }
-}
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/removeCompleteContourAnnotation.js
-
-
-function removeCompleteContourAnnotation_removeCompleteContourAnnotation(annotation) {
-    if (!annotation) {
-        return;
-    }
-    if (annotation.parentAnnotationUID) {
-        clearParentAnnotation(annotation);
-    }
-    removeAnnotation(annotation.annotationUID);
-    removeContourSegmentationAnnotation(annotation);
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contours/index.js + 6 modules
-var contours = __webpack_require__(6936);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/removeContourHoles.js
-
-
-
-
-
-function removeContourHoles(segmentationId, segmentIndex) {
-    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 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]);
-                removeCompleteContourAnnotation(annotation);
-            });
-        });
-    }
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contours/findIslands.js
-var contours_findIslands = __webpack_require__(76617);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/removeContourIslands.js
-
-
-
-
-
-function removeContourIslands(segmentationId, segmentIndex, options = { threshold: 3 }) {
-    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 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 islands = findIslands(polylines, options.threshold);
-    if (islands?.length > 0) {
-        islands.forEach((index) => {
-            const annotation = getAnnotation(keys[index]);
-            removeCompleteContourAnnotation(annotation);
-        });
-    }
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planarFreehandROITool/interpolation/interpolateSegmentPoints.js
-var interpolation_interpolateSegmentPoints = __webpack_require__(61768);
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/smoothContours.js
-
-
-
-function smoothContours(segmentationId, segmentIndex, options = { knotsRatioPercentage: 30 }) {
-    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 contourRepresentationData = segmentation.representationData
-        .Contour;
-    const { annotationUIDsMap } = contourRepresentationData;
-    if (!annotationUIDsMap) {
-        console.warn(`No contours found for segmentation ${segmentationId}`);
-        return;
-    }
-    if (!annotationUIDsMap.has(segmentIndex)) {
-        console.warn(`Error extracting contour data from segment ${segmentIndex} in segmentation ${segmentationId}`);
-        return;
-    }
-    const annotationList = annotationUIDsMap.get(segmentIndex);
-    annotationList.forEach((annotationUID) => {
-        const annotation = getAnnotation(annotationUID);
-        if (!annotation) {
-            return;
-        }
-        const polyline = annotation.data.contour.polyline;
-        if (!polyline || polyline.length < 3) {
-            return;
-        }
-        const smoothedPolyline = interpolateSegmentPoints(polyline, 0, polyline.length - 1, options.knotsRatioPercentage);
-        annotation.data.contour.polyline = smoothedPolyline;
-    });
-}
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/convertContourHoles.js
-
-
-
-
-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);
-                }
-            });
-        });
-    }
-}
-
-;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/index.js
-
-
-
-
-
-
-
-
-
-
-
-
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/utilities/index.js
+var utilities = __webpack_require__(31994);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/convertStackToVolumeLabelmap.js
 var convertStackToVolumeLabelmap = __webpack_require__(6273);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack.js
 var computeVolumeLabelmapFromStack = __webpack_require__(6994);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
 var esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var segmentation_getSegmentation = __webpack_require__(33283);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/clearSegmentValue.js
 
 
@@ -33933,6 +33602,10 @@ var computeStackLabelmapFromVolume = __webpack_require__(93690);
 var segmentation_getActiveSegmentIndex = __webpack_require__(60740);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getViewportIdsWithSegmentation.js
 var segmentation_getViewportIdsWithSegmentation = __webpack_require__(58859);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
+var annotationState = __webpack_require__(82056);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/index.js + 1 modules
+var contourSegmentation = __webpack_require__(56534);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/removeSegmentAnnotations.js
 
 
@@ -34408,9 +34081,26 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   setSegmentIndexLocked: () => (/* binding */ setSegmentIndexLocked)
 /* harmony export */ });
 /* harmony import */ var _stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33283);
-/* harmony import */ var _triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
+/* harmony import */ var _annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2076);
+/* harmony import */ var _triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49906);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(31994);
+
 
 
+
+function _setContourSegmentationSegmentAnnotationsLocked(segmentation, segmentIndex, locked) {
+    const annotationUIDsMap = (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.getAnnotationsUIDMapFromSegmentation)(segmentation.segmentationId);
+    if (!annotationUIDsMap) {
+        return;
+    }
+    const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+    if (!annotationUIDs) {
+        return;
+    }
+    annotationUIDs.forEach((annotationUID) => {
+        (0,_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_1__.setAnnotationLocked)(annotationUID, locked);
+    });
+}
 function isSegmentIndexLocked(segmentationId, segmentIndex) {
     const segmentation = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__/* .getSegmentation */ .T)(segmentationId);
     if (!segmentation) {
@@ -34426,7 +34116,10 @@ function setSegmentIndexLocked(segmentationId, segmentIndex, locked = true) {
     }
     const { segments } = segmentation;
     segments[segmentIndex].locked = locked;
-    (0,_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__.triggerSegmentationModified)(segmentationId);
+    if (segmentation?.representationData?.Contour) {
+        _setContourSegmentationSegmentAnnotationsLocked(segmentation, segmentIndex, locked);
+    }
+    (0,_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__.triggerSegmentationModified)(segmentationId);
 }
 function getLockedSegmentIndices(segmentationId) {
     const segmentation = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__/* .getSegmentation */ .T)(segmentationId);
@@ -34560,6 +34253,67 @@ function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
 }
 
 
+/***/ }),
+
+/***/ 98484:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   B: () => (/* binding */ getAnnotationsUIDMapFromSegmentation)
+/* harmony export */ });
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33283);
+
+function getAnnotationsUIDMapFromSegmentation(segmentationId) {
+    const segmentation = (0,_getSegmentation__WEBPACK_IMPORTED_MODULE_0__/* .getSegmentation */ .T)(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    const contourRepresentationData = segmentation.representationData
+        ?.Contour;
+    if (!contourRepresentationData) {
+        return;
+    }
+    const { annotationUIDsMap } = contourRepresentationData;
+    if (!annotationUIDsMap) {
+        return;
+    }
+    return annotationUIDsMap;
+}
+
+
+/***/ }),
+
+/***/ 31994:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getAnnotationsUIDMapFromSegmentation: () => (/* reexport safe */ _getAnnotationsUIDMapFromSegmentation__WEBPACK_IMPORTED_MODULE_0__.B)
+/* harmony export */ });
+/* harmony import */ var _getAnnotationsUIDMapFromSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98484);
+/* harmony import */ var _getViewportAssociatedToSegmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16493);
+/* harmony import */ var _getAnnotationMapFromSegmentation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10407);
+/* harmony import */ var _decimateContours__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(53097);
+/* harmony import */ var _extractSegmentPolylines__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(96629);
+/* harmony import */ var _removeCompleteContourAnnotation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(38928);
+/* harmony import */ var _removeContourHoles__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(19741);
+/* harmony import */ var _removeContourIslands__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(85512);
+/* harmony import */ var _smoothContours__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(68362);
+/* harmony import */ var _convertContourHoles__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(64540);
+
+
+
+
+
+
+
+
+
+
+
+
+
 /***/ }),
 
 /***/ 65136:
@@ -35663,13 +35417,11 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
                 else {
                     this.updateOpenCachedStats({
                         metadata,
-                        canvasCoordinates,
                         targetId,
                         cachedStats,
                         modalityUnit,
                         calibratedScale,
-                        deltaInX,
-                        deltaInY,
+                        points,
                     });
                 }
             }
@@ -35922,8 +35674,7 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
         worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
         let area = _utilities_math__WEBPACK_IMPORTED_MODULE_4__.polyline.getArea(canvasCoordinates) / scale / scale;
         area *= deltaInX * deltaInY;
-        let perimeter = (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_21__/* ["default"] */ .A)(canvasCoordinates, closed) / scale;
-        perimeter *= Math.sqrt(Math.pow(deltaInX, 2) + Math.pow(deltaInY, 2));
+        const perimeter = (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_21__/* ["default"] */ .A)(points, closed) / scale;
         const iDelta = 0.01 * (iMax - iMin);
         const jDelta = 0.01 * (jMax - jMin);
         const kDelta = 0.01 * (kMax - kMin);
@@ -35993,10 +35744,9 @@ class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_I
             unit,
         };
     }
-    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, deltaInX, deltaInY, }) {
+    updateOpenCachedStats({ targetId, metadata, cachedStats, modalityUnit, calibratedScale, points, }) {
         const { scale, unit } = calibratedScale;
-        let length = (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_21__/* ["default"] */ .A)(canvasCoordinates, closed) / scale;
-        length *= Math.sqrt(Math.pow(deltaInX, 2) + Math.pow(deltaInY, 2));
+        const length = (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_21__/* ["default"] */ .A)(points, closed) / scale;
         cachedStats[targetId] = {
             Modality: metadata.Modality,
             length,
@@ -38917,59 +38667,6 @@ function pointInSphere(sphere, pointLPS) {
 
 
 
-/***/ }),
-
-/***/ 61768:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ interpolateSegmentPoints)
-/* harmony export */ });
-/* harmony import */ var _algorithms_bspline__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(30269);
-
-function getContinuousUniformDistributionValues(minDistributionDistance, closedInterval) {
-    const result = [];
-    const [intervalIni, intervalEnd] = closedInterval;
-    const intervalSize = intervalEnd - intervalIni + 1;
-    const intensity = Math.floor(intervalSize / minDistributionDistance);
-    let x = 0;
-    let continuosDistributionValue = Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
-    while (continuosDistributionValue <= intervalEnd) {
-        result.push(continuosDistributionValue);
-        x++;
-        continuosDistributionValue =
-            Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
-    }
-    return result;
-}
-function interpolateSegmentPoints(points, iniIndex, endIndex, knotsRatioPercentage) {
-    const segmentSize = endIndex - iniIndex + 1;
-    const amountOfKnots = Math.floor((knotsRatioPercentage / 100) * segmentSize) ?? 1;
-    const minKnotDistance = Math.floor(segmentSize / amountOfKnots) ?? 1;
-    if (isNaN(segmentSize) || !segmentSize || !minKnotDistance) {
-        return points;
-    }
-    if (segmentSize / minKnotDistance < 2) {
-        return points;
-    }
-    const interpolationIniIndex = Math.max(0, iniIndex);
-    const interpolationEndIndex = Math.min(points.length - 1, endIndex);
-    const segmentPointsUnchangedBeg = points.slice(0, interpolationIniIndex);
-    const segmentPointsUnchangedEnd = points.slice(interpolationEndIndex + 1, points.length);
-    const knotsIndexes = getContinuousUniformDistributionValues(minKnotDistance, [
-        interpolationIniIndex,
-        interpolationEndIndex,
-    ]);
-    const interpolatedPoints = (0,_algorithms_bspline__WEBPACK_IMPORTED_MODULE_0__/* .interpolatePoints */ .H)(points, knotsIndexes);
-    return [
-        ...segmentPointsUnchangedBeg,
-        ...interpolatedPoints,
-        ...segmentPointsUnchangedEnd,
-    ];
-}
-
-
 /***/ }),
 
 /***/ 13179: