@ohif/app 3.12.0-beta.66 → 3.12.0-beta.68

package/dist/{1447.bundle.4ce931c66306039c9524.js → 1447.bundle.42a201eb7cfb535dbb27.js}

@@ -10394,8 +10394,8 @@ function AboutModalDefault() {
     name
   } = (0,browser_detect_es5/* default */.A)();
   const browser = `${name[0].toUpperCase()}${name.substr(1)} ${version}`;
-  const versionNumber = "3.12.0-beta.66";
-  const commitHash = "42aa2df62622ab380f97025819bd929fa0579e14";
+  const versionNumber = "3.12.0-beta.68";
+  const commitHash = "170e860aa1b786ab6056cf31076804302a2bc462";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"

package/dist/{2518.bundle.57c229a14e22d23db384.js → 2518.bundle.80f6f53d5a171288d177.js}

@@ -5655,6 +5655,7 @@ function labelmapImagesFromBuffer_insertPixelDataPlanar(_ref4) {
         const imageIdIndex = imageIdMaps.indices[imageId];
         const labelmapImage = labelMapImages[imageIdIndex];
         const labelmap2DView = labelmapImage.getPixelData();
+        const imageVoxelManager = labelmapImage.voxelManager;
         const data = alignedPixelDataI.data;
         const indexCache = [];
         for (let k = 0, len = alignedPixelDataI.data.length; k < len; ++k) {
@@ -5677,7 +5678,11 @@ function labelmapImagesFromBuffer_insertPixelDataPlanar(_ref4) {
                     imageIdMaps
                   }));
                 }
-                labelmap2DView[x] = segmentIndex;
+                if (imageVoxelManager) {
+                  imageVoxelManager.setAtIndex(x, segmentIndex);
+                } else {
+                  labelmap2DView[x] = segmentIndex;
+                }
                 indexCache.push(x);
               }
             }

package/dist/{319.bundle.fc959064ddf2f6978b54.js → 319.bundle.cd9383a345b9da2ba840.js}

@@ -2214,7 +2214,7 @@ class CircleSculptCursor {
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(85817);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(99737);
-/* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(83673);
+/* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(55126);
 /* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49906);
 /* harmony import */ var _utilities_segmentation_growCut_constants__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10564);
 /* harmony import */ var _utilities_segmentation_getSVGStyleForSegment__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(86644);

package/dist/{3409.bundle.c4ddac8992b11938c3ea.js → 3409.bundle.fc5d04563e48e2d9509c.js}

@@ -10346,10 +10346,23 @@ function commandsModule({
       if (displaySet.Modality === 'SEG' || displaySet.Modality === 'RTSTRUCT') {
         const referencedDisplaySet = displaySetService.getDisplaySetByUID(referencedDisplaySetInstanceUID);
         storePositionPresentation(referencedDisplaySet);
-        return commandsManager.runCommand('loadSegmentationDisplaySetsForViewport', {
+        const results = commandsManager.runCommand('loadSegmentationDisplaySetsForViewport', {
           viewportId,
           displaySetInstanceUIDs: [referencedDisplaySet.displaySetInstanceUID]
         });
+        const disableEditing = customizationService.getCustomization('panelSegmentation.disableEditing');
+        if (disableEditing) {
+          const segmentationRepresentations = segmentationService.getSegmentationRepresentations(viewportId, {
+            segmentationId: displaySet.displaySetInstanceUID
+          });
+          segmentationRepresentations.forEach(representation => {
+            const segmentIndices = Object.keys(representation.segments);
+            segmentIndices.forEach(segmentIndex => {
+              segmentationService.setSegmentLocked(representation.segmentationId, parseInt(segmentIndex), true);
+            });
+          });
+        }
+        return results;
       } else if (displaySet.Modality === 'SR') {
         const results = commandsManager.runCommand('hydrateStructuredReport', {
           displaySetInstanceUID: displaySet.displaySetInstanceUID

package/dist/{9819.bundle.29fb49e6d25cf486a204.js → 3613.bundle.f54ec42efcfa4f83656c.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9819],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3613],{
 
 /***/ 86871:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -34390,7 +34390,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.5.5';
+const version = '4.5.13';
 
 
 /***/ }),
@@ -36291,9 +36291,10 @@ const defaultFrameOfReferenceSpecificAnnotationManager = new FrameOfReferenceSpe
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   checkAndSetAnnotationLocked: () => (/* binding */ checkAndSetAnnotationLocked),
-/* harmony export */   isAnnotationLocked: () => (/* binding */ isAnnotationLocked)
+/* harmony export */   isAnnotationLocked: () => (/* binding */ isAnnotationLocked),
+/* harmony export */   setAnnotationLocked: () => (/* binding */ setAnnotationLocked)
 /* harmony export */ });
-/* unused harmony exports setAnnotationLocked, getAnnotationsLocked, getAnnotationsLockedCount, unlockAllAnnotations */
+/* unused harmony exports getAnnotationsLocked, getAnnotationsLockedCount, unlockAllAnnotations */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99737);
 /* harmony import */ var _annotationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(82056);
@@ -37376,28 +37377,278 @@ function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
 
 /***/ }),
 
-/***/ 98484:
+/***/ 64540:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony export getAnnotationsUIDMapFromSegmentation */
-/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33283);
+/* unused harmony export default */
+/* harmony import */ var _utilities_contours__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6936);
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(82056);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33283);
+/* harmony import */ var _extractSegmentPolylines__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(96629);
+
+
 
-function getAnnotationsUIDMapFromSegmentation(segmentationId) {
+
+function convertContourHoles(segmentationId, segmentIndex, targetSegmentationId, targetSegmentationIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
+        console.warn(`Invalid segmentation given ${segmentationId}`);
         return;
     }
-    const contourRepresentationData = segmentation.representationData
-        ?.Contour;
-    if (!contourRepresentationData) {
+    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);
+                }
+            });
+        });
+    }
+}
+
+
+/***/ }),
+
+/***/ 53097:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export default */
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33283);
+/* harmony import */ var _extractSegmentPolylines__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96629);
+/* harmony import */ var _utilities_math_polyline_decimate__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99944);
+/* harmony import */ var _getViewportAssociatedToSegmentation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(16493);
+
+
+
+
+
+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);
+        }
+    }
+}
+
+
+/***/ }),
+
+/***/ 96629:
+/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// UNUSED EXPORTS: extractSegmentPolylines
+
+// 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);
+// 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/segmentation/utilities/getAnnotationMapFromSegmentation.js
+var utilities_getAnnotationMapFromSegmentation = __webpack_require__(10407);
+;// ../../../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;
+}
+
+// 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/extractSegmentPolylines.js
+
+
+
+
+
+function 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;
     }
-    return annotationUIDsMap;
+    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;
+}
+
+
+/***/ }),
+
+/***/ 10407:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export getAnnotationMapFromSegmentation */
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
+
+function 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 };
 }
 
 
@@ -37455,6 +37706,169 @@ function getViewportWithMatchingViewPlaneNormal(viewports, annotation, dotThresh
 }
 
 
+/***/ }),
+
+/***/ 38928:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export removeCompleteContourAnnotation */
+/* harmony import */ var _utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56534);
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(82056);
+
+
+function removeCompleteContourAnnotation(annotation) {
+    if (!annotation) {
+        return;
+    }
+    if (annotation.parentAnnotationUID) {
+        clearParentAnnotation(annotation);
+    }
+    removeAnnotation(annotation.annotationUID);
+    removeContourSegmentationAnnotation(annotation);
+}
+
+
+/***/ }),
+
+/***/ 19741:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export default */
+/* harmony import */ var _utilities_contours__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6936);
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(82056);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33283);
+/* harmony import */ var _extractSegmentPolylines__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(96629);
+/* harmony import */ var _removeCompleteContourAnnotation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(38928);
+
+
+
+
+
+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);
+            });
+        });
+    }
+}
+
+
+/***/ }),
+
+/***/ 85512:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export default */
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33283);
+/* harmony import */ var _extractSegmentPolylines__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96629);
+/* harmony import */ var _utilities_contours_findIslands__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(76617);
+/* harmony import */ var _removeCompleteContourAnnotation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(38928);
+
+
+
+
+
+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);
+        });
+    }
+}
+
+
+/***/ }),
+
+/***/ 68362:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export default */
+/* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33283);
+/* harmony import */ var _utilities_planarFreehandROITool_interpolation_interpolateSegmentPoints__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(61768);
+
+
+
+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;
+    });
+}
+
+
 /***/ }),
 
 /***/ 77609:
@@ -39847,7 +40261,9 @@ var ContourWindingDirection;
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   V: () => (/* binding */ addContourSegmentationAnnotation)
 /* harmony export */ });
-/* harmony import */ var _stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33283);
+/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2076);
+/* harmony import */ var _stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33283);
+
 
 function addContourSegmentationAnnotation(annotation) {
     if (annotation.parentAnnotationUID) {
@@ -39857,7 +40273,7 @@ function addContourSegmentationAnnotation(annotation) {
         throw new Error('addContourSegmentationAnnotation: annotation does not have a segmentation data');
     }
     const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_0__/* .getSegmentation */ .T)(segmentationId);
+    const segmentation = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_1__/* .getSegmentation */ .T)(segmentationId);
     if (!segmentation.representationData.Contour) {
         segmentation.representationData.Contour = { annotationUIDsMap: new Map() };
     }
@@ -39870,6 +40286,9 @@ function addContourSegmentationAnnotation(annotation) {
         annotationsUIDsSet = new Set();
         annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
     }
+    if (segmentation.segments[segmentIndex].locked) {
+        (0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_0__.setAnnotationLocked)(annotation.annotationUID, true);
+    }
     annotationUIDsMap.set(segmentIndex, annotationsUIDsSet.add(annotation.annotationUID));
 }
 
@@ -42119,6 +42538,59 @@ function normalizeViewportPlane(viewport, boundsIJK) {
 }
 
 
+/***/ }),
+
+/***/ 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,
+    ];
+}
+
+
 /***/ }),
 
 /***/ 37162:

package/dist/{4019.bundle.13e7f662a9e489b74a27.js → 4019.bundle.2f21e5bc490fc3b743a8.js}

@@ -2022,6 +2022,12 @@ class AnnotationTool extends _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__
     createMemo(element, annotation, options) {
         this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
     }
+    startGroupRecording() {
+        DefaultHistoryMemo.startGroupRecording();
+    }
+    endGroupRecording() {
+        DefaultHistoryMemo.endGroupRecording();
+    }
     static hydrateBase(ToolClass, enabledElement, points, options = {}) {
         if (!enabledElement) {
             return null;