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

package/dist/{9819.bundle.29fb49e6d25cf486a204.js → 3613.bundle.14721af2527117f720b0.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__) => {
@@ -19456,6 +19456,7 @@ class ImageVolume {
                     dimensions,
                     imageIds,
                     numberOfComponents,
+                    id: volumeId,
                 });
         this.numVoxels =
             this.dimensions[0] * this.dimensions[1] * this.dimensions[2];
@@ -34390,7 +34391,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.5.5';
+const version = '4.5.19';
 
 
 /***/ }),
@@ -36291,9 +36292,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 +37378,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 +37707,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 +40262,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 +40274,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 +40287,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));
 }
 
@@ -41181,18 +41601,20 @@ function cleanupPolylines(polylines) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
+/* unused harmony export calculatePerimeter */
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
+
 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));
+        perimeter += gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dist */ .eR.dist(point1, point2);
     }
     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));
+        perimeter += gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dist */ .eR.dist(firstPoint, lastPoint);
     }
     return perimeter;
 }
@@ -42119,6 +42541,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.acd0f85d0467cb10d86a.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;
@@ -5124,19 +5130,20 @@ function filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirect
     const { focalPoint } = camera;
     const annotationsWithinSlice = [];
     for (const annotation of annotationsWithParallelNormals) {
-        const data = annotation.data;
-        const point = data.handles.points[0] || data.contour?.polyline[0];
-        if (!annotation.isVisible) {
+        const { data, metadata, isVisible } = annotation;
+        if (!isVisible) {
             continue;
         }
-        const dir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        const point = metadata.planeRestriction?.point ||
+            data.handles.points[0] ||
+            data.contour?.polyline[0];
         if (!point) {
             annotationsWithinSlice.push(annotation);
             continue;
         }
-        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(dir, focalPoint, point);
-        const dot = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(dir, viewPlaneNormal);
-        if (Math.abs(dot) < halfSpacingInNormalDirection) {
+        const dir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), focalPoint, point);
+        const dot = Math.abs(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(dir, viewPlaneNormal));
+        if (dot < halfSpacingInNormalDirection) {
             annotationsWithinSlice.push(annotation);
         }
     }