@ohif/app 3.12.0-beta.133 → 3.12.0-beta.134

package/dist/{3081.bundle.c97d56344e5008acbaba.js → 3081.bundle.9f62df4f5aff3aa7912b.js}

@@ -9723,6 +9723,11 @@ async function updateSegmentationStats({
   // Loop through each segment's stats
   Object.entries(stats).forEach(([segmentIndex, segmentStats]) => {
     const index = parseInt(segmentIndex);
+    if (!updatedSegmentation.segments[index]) {
+      // This happens when a segment is being restored
+      console.warn('Segment not found to update cached stats:', index);
+      return;
+    }
     if (!updatedSegmentation.segments[index].cachedStats) {
       updatedSegmentation.segments[index].cachedStats = {};
       hasUpdates = true;
@@ -19130,6 +19135,9 @@ var _SegmentationService;
 
 
 
+const {
+  DefaultHistoryMemo: SegmentationService_DefaultHistoryMemo
+} = esm.utilities.HistoryMemo;
 const {
   Labelmap: LABELMAP,
   Contour: CONTOUR,
@@ -19890,11 +19898,69 @@ class SegmentationService extends src/* PubSubService */.Rc {
     });
   }
 
+  /**
+   * Creates a memo that records the current state of a segment (segmentationId/segmentIndex)
+   * so that undo can restore it via addSegment and redo can call removeSegment again
+   * without recording history.
+   *
+   * @param segmentationId - The ID of the segmentation.
+   * @param segmentIndex - The index of the segment (must still exist when called).
+   * @param _options - Reserved (e.g. deleting) for future use.
+   * @returns A Memo with restoreMemo(undo): undo => addSegment, redo => removeSegment (skipRecordingHistory).
+   */
+  createSegmentIndexMemo(segmentationId, segmentIndex, _options) {
+    const csSegmentation = this.getCornerstoneSegmentation(segmentationId);
+    const segment = csSegmentation?.segments?.[segmentIndex];
+    if (!segment) {
+      return null;
+    }
+    let color;
+    let visibility;
+    const viewportIds = this.getViewportIdsWithSegmentation(segmentationId);
+    if (viewportIds.length > 0) {
+      const firstViewportId = viewportIds[0];
+      const representations = this.getSegmentationRepresentations(firstViewportId, {
+        segmentationId
+      });
+      const repType = representations[0]?.type ?? LABELMAP;
+      color = this.getSegmentColor(firstViewportId, segmentationId, segmentIndex);
+      visibility = dist_esm.segmentation.config.visibility.getSegmentIndexVisibility(firstViewportId, {
+        segmentationId,
+        type: repType
+      }, segmentIndex);
+    }
+    const segmentState = {
+      segmentIndex,
+      label: segment.label,
+      isLocked: segment.locked,
+      active: segment.active,
+      color,
+      visibility
+    };
+    const service = this;
+    const memo = {
+      id: esm.utilities.uuidv4(),
+      operationType: 'segmentIndex',
+      restoreMemo(undo) {
+        if (undo === true) {
+          service.addSegment(segmentationId, segmentState);
+        } else {
+          // Redo: remove the segment via cornerstone without recording history
+          dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+            recordHistory: false
+          });
+        }
+      }
+    };
+    return memo;
+  }
+
   /**
    * Removes a segment from a segmentation and updates the active segment index if necessary.
    *
    * @param segmentationId - The ID of the segmentation containing the segment to remove.
    * @param segmentIndex - The index of the segment to remove.
+   * @param options - Optional. skipRecordingHistory: if true, do not push undo memo (used when redoing).
    *
    * @remarks
    * This method performs the following actions:
@@ -19903,8 +19969,23 @@ class SegmentationService extends src/* PubSubService */.Rc {
    * 3. If the removed segment was the active segment, it updates the active segment index.
    *
    */
-  removeSegment(segmentationId, segmentIndex) {
-    dist_esm.segmentation.removeSegment(segmentationId, segmentIndex);
+  removeSegment(segmentationId, segmentIndex, options) {
+    let memo;
+    if (!options?.skipRecordingHistory) {
+      memo = this.createSegmentIndexMemo(segmentationId, segmentIndex, {
+        deleting: true
+      });
+      SegmentationService_DefaultHistoryMemo.startGroupRecording();
+      dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+        recordHistory: true
+      });
+      SegmentationService_DefaultHistoryMemo.push(memo);
+      SegmentationService_DefaultHistoryMemo.endGroupRecording();
+    } else {
+      dist_esm.segmentation.removeSegment(segmentationId, segmentIndex, {
+        recordHistory: false
+      });
+    }
   }
   setSegmentVisibility(viewportId, segmentationId, segmentIndex, isVisible, type) {
     this._setSegmentVisibility(viewportId, segmentationId, segmentIndex, isVisible, type);

package/dist/{4019.bundle.fd035b6abe8792af15f2.js → 4019.bundle.83a604779f7da0101ced.js}

@@ -1778,306 +1778,6 @@ function registerRenderMethods(toolInstance) {
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (registerRenderMethods);
 
 
-/***/ }),
-
-/***/ 91350:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
-/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
-/* harmony import */ var _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6030);
-/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2076);
-/* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29601);
-/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82056);
-/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(44049);
-/* harmony import */ var _enums_ChangeTypes__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(75183);
-/* harmony import */ var _stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(17343);
-/* harmony import */ var _utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(56534);
-/* harmony import */ var _utilities_safeStructuredClone__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(33459);
-
-
-
-
-
-
-
-
-
-
-
-const { DefaultHistoryMemo } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.HistoryMemo;
-class AnnotationTool extends _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A {
-    static createAnnotationForViewport(viewport, ...annotationBaseData) {
-        return this.createAnnotation({ metadata: viewport.getViewReference() }, ...annotationBaseData);
-    }
-    static createAndAddAnnotation(viewport, ...annotationBaseData) {
-        const annotation = this.createAnnotationForViewport(viewport, ...annotationBaseData);
-        (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, viewport.element);
-        (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_6__.triggerAnnotationModified)(annotation, viewport.element);
-    }
-    constructor(toolProps, defaultToolProps) {
-        super(toolProps, defaultToolProps);
-        this.mouseMoveCallback = (evt, filteredAnnotations) => {
-            if (!filteredAnnotations) {
-                return false;
-            }
-            const { element, currentPoints } = evt.detail;
-            const canvasCoords = currentPoints.canvas;
-            let annotationsNeedToBeRedrawn = false;
-            for (const annotation of filteredAnnotations) {
-                if ((0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_3__.isAnnotationLocked)(annotation.annotationUID) ||
-                    !(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_4__.isAnnotationVisible)(annotation.annotationUID)) {
-                    continue;
-                }
-                const { data } = annotation;
-                const activateHandleIndex = data.handles
-                    ? data.handles.activeHandleIndex
-                    : undefined;
-                const near = this._imagePointNearToolOrHandle(element, annotation, canvasCoords, 6);
-                const nearToolAndNotMarkedActive = near && !annotation.highlighted;
-                const notNearToolAndMarkedActive = !near && annotation.highlighted;
-                if (nearToolAndNotMarkedActive || notNearToolAndMarkedActive) {
-                    annotation.highlighted = !annotation.highlighted;
-                    annotationsNeedToBeRedrawn = true;
-                }
-                else if (data.handles &&
-                    data.handles.activeHandleIndex !== activateHandleIndex) {
-                    annotationsNeedToBeRedrawn = true;
-                }
-            }
-            return annotationsNeedToBeRedrawn;
-        };
-        this.isSuvScaled = AnnotationTool.isSuvScaled;
-        if (toolProps.configuration?.getTextLines) {
-            this.configuration.getTextLines = toolProps.configuration.getTextLines;
-        }
-        if (toolProps.configuration?.statsCalculator) {
-            this.configuration.statsCalculator =
-                toolProps.configuration.statsCalculator;
-        }
-    }
-    getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
-        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
-        const { viewport } = enabledElement;
-        const { data } = annotation;
-        const { isCanvasAnnotation } = data;
-        const { points, textBox } = data.handles;
-        if (textBox) {
-            const { worldBoundingBox } = textBox;
-            if (worldBoundingBox) {
-                const canvasBoundingBox = {
-                    topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
-                    topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
-                    bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
-                    bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
-                };
-                if (canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
-                    canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
-                    canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
-                    canvasCoords[1] <= canvasBoundingBox.bottomRight[1]) {
-                    data.handles.activeHandleIndex = null;
-                    return textBox;
-                }
-            }
-        }
-        for (let i = 0; i < points?.length; i++) {
-            const point = points[i];
-            const annotationCanvasCoordinate = isCanvasAnnotation
-                ? point.slice(0, 2)
-                : viewport.worldToCanvas(point);
-            const near = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.distance */ .Zc.distance(canvasCoords, annotationCanvasCoordinate) < proximity;
-            if (near === true) {
-                data.handles.activeHandleIndex = i;
-                return point;
-            }
-        }
-        data.handles.activeHandleIndex = null;
-    }
-    getLinkedTextBoxStyle(specifications, annotation) {
-        return {
-            visibility: this.getStyle('textBoxVisibility', specifications, annotation),
-            fontFamily: this.getStyle('textBoxFontFamily', specifications, annotation),
-            fontSize: this.getStyle('textBoxFontSize', specifications, annotation),
-            color: this.getStyle('textBoxColor', specifications, annotation),
-            shadow: this.getStyle('textBoxShadow', specifications, annotation),
-            background: this.getStyle('textBoxBackground', specifications, annotation),
-            lineWidth: this.getStyle('textBoxLinkLineWidth', specifications, annotation),
-            lineDash: this.getStyle('textBoxLinkLineDash', specifications, annotation),
-            textBoxBorderRadius: this.getStyle('textBoxBorderRadius', specifications, annotation),
-            textBoxMargin: this.getStyle('textBoxMargin', specifications, annotation),
-            textBoxLinkLineColor: this.getStyle('textBoxLinkLineColor', specifications, annotation),
-        };
-    }
-    static isSuvScaled(viewport, targetId, imageId) {
-        if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport) {
-            const volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeId(targetId);
-            const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
-            return volume?.scaling?.PT !== undefined;
-        }
-        const scalingModule = imageId && _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.metaData.get('scalingModule', imageId);
-        return typeof scalingModule?.suvbw === 'number';
-    }
-    getAnnotationStyle(context) {
-        const { annotation, styleSpecifier } = context;
-        const getStyle = (property) => this.getStyle(property, styleSpecifier, annotation);
-        const { annotationUID } = annotation;
-        const visibility = (0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_4__.isAnnotationVisible)(annotationUID);
-        const locked = (0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_3__.isAnnotationLocked)(annotationUID);
-        const lineWidth = getStyle('lineWidth');
-        const lineDash = getStyle('lineDash');
-        const angleArcLineDash = getStyle('angleArcLineDash');
-        const color = getStyle('color');
-        const markerSize = getStyle('markerSize');
-        const shadow = getStyle('shadow');
-        const textboxStyle = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
-        return {
-            visibility,
-            locked,
-            color,
-            lineWidth,
-            lineDash,
-            lineOpacity: 1,
-            fillColor: color,
-            fillOpacity: 0,
-            shadow,
-            textbox: textboxStyle,
-            markerSize,
-            angleArcLineDash,
-        };
-    }
-    _imagePointNearToolOrHandle(element, annotation, canvasCoords, proximity) {
-        const handleNearImagePoint = this.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
-        if (handleNearImagePoint) {
-            return true;
-        }
-        const toolNewImagePoint = this.isPointNearTool(element, annotation, canvasCoords, proximity, 'mouse');
-        if (toolNewImagePoint) {
-            return true;
-        }
-    }
-    static createAnnotationState(annotation, deleting) {
-        const { data, annotationUID } = annotation;
-        return {
-            annotationUID,
-            data: (0,_utilities_safeStructuredClone__WEBPACK_IMPORTED_MODULE_10__/* .safeStructuredClone */ .W)(data),
-            deleting,
-        };
-    }
-    static createAnnotationMemo(element, annotation, options) {
-        if (!annotation) {
-            return;
-        }
-        const { newAnnotation, deleting = newAnnotation ? false : undefined } = options || {};
-        const { annotationUID } = annotation;
-        const state = AnnotationTool.createAnnotationState(annotation, deleting);
-        const annotationMemo = {
-            restoreMemo: () => {
-                const newState = AnnotationTool.createAnnotationState(annotation, deleting);
-                const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element) || {};
-                viewport?.setViewReference(annotation.metadata);
-                if (state.deleting === true) {
-                    state.deleting = false;
-                    Object.assign(annotation.data, state.data);
-                    if (annotation.data.contour) {
-                        const annotationData = annotation.data;
-                        annotationData.contour.polyline = state.data.contour.pointsManager.points;
-                        delete state.data.contour.pointsManager;
-                        if (annotationData.segmentation) {
-                            (0,_utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_9__.addContourSegmentationAnnotation)(annotation);
-                        }
-                    }
-                    state.data = newState.data;
-                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, element);
-                    (0,_stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__.setAnnotationSelected)(annotation.annotationUID, true);
-                    viewport?.render();
-                    return;
-                }
-                if (state.deleting === false) {
-                    state.deleting = true;
-                    state.data = newState.data;
-                    (0,_stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__.setAnnotationSelected)(annotation.annotationUID);
-                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotation.annotationUID);
-                    viewport?.render();
-                    return;
-                }
-                const currentAnnotation = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.getAnnotation)(annotationUID);
-                if (!currentAnnotation) {
-                    console.warn('No current annotation');
-                    return;
-                }
-                Object.assign(currentAnnotation.data, state.data);
-                if (currentAnnotation.data.contour) {
-                    currentAnnotation.data
-                        .contour.polyline = state.data.contour.pointsManager.points;
-                }
-                state.data = newState.data;
-                currentAnnotation.invalidated = true;
-                (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_6__.triggerAnnotationModified)(currentAnnotation, element, _enums_ChangeTypes__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A.History);
-            },
-            id: annotationUID,
-            operationType: 'annotation',
-        };
-        DefaultHistoryMemo.push(annotationMemo);
-        return annotationMemo;
-    }
-    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;
-        }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const camera = viewport.getCamera();
-        const viewPlaneNormal = options.viewplaneNormal ?? camera.viewPlaneNormal;
-        const viewUp = options.viewUp ?? camera.viewUp;
-        const instance = options.toolInstance || new ToolClass();
-        let referencedImageId;
-        let finalViewPlaneNormal = viewPlaneNormal;
-        let finalViewUp = viewUp;
-        if (options.referencedImageId) {
-            referencedImageId = options.referencedImageId;
-            finalViewPlaneNormal = undefined;
-            finalViewUp = undefined;
-        }
-        else {
-            if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.StackViewport) {
-                const closestImageIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getClosestStackImageIndexForPoint(points[0], viewport);
-                if (closestImageIndex !== undefined) {
-                    referencedImageId = viewport.getImageIds()[closestImageIndex];
-                }
-            }
-            else if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport) {
-                referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
-            }
-            else {
-                throw new Error('Unsupported viewport type');
-            }
-        }
-        return {
-            FrameOfReferenceUID,
-            referencedImageId,
-            viewPlaneNormal: finalViewPlaneNormal,
-            viewUp: finalViewUp,
-            instance,
-            viewport,
-        };
-    }
-}
-AnnotationTool.toolName = 'AnnotationTool';
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AnnotationTool);
-
-
 /***/ }),
 
 /***/ 36320:

package/dist/{4410.bundle.c563b02780d4bd1efc91.js → 4410.bundle.c5224cd7d6238a7d4660.js}

@@ -35500,7 +35500,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.15.28';
+const version = '4.15.29';
 
 
 /***/ }),
@@ -44405,8 +44405,6 @@ function createBidirectionalToolData(bidirectionalData, viewport) {
 /* unused harmony exports restoreMemo, createRleMemo */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
-/* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(94021);
-
 
 
 const { VoxelManager, RLEVoxelMap } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;