@ohif/app 3.12.0-beta.52 → 3.12.0-beta.54

package/dist/{9892.bundle.83de6c11c8a9eb4bba25.js → 9892.bundle.14e773b29e191babc8e4.js}

@@ -6925,7 +6925,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.3.14';
+const version = '4.5.3';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 
@@ -7874,6 +7874,7 @@ var stackPrefetchUtils = __webpack_require__(94762);
 
 
 
+
 const { imageRetrieveMetadataProvider } = esm.utilities;
 let configuration = {
     maxImagesToPrefetch: Infinity,
@@ -7933,6 +7934,13 @@ function prefetch(element) {
         console.log('prefetch done: %s', imageId);
         const imageIdIndex = stack.imageIds.indexOf(imageId);
         removeFromList(imageIdIndex);
+        if (stackPrefetch.indicesToRequest.length === 0) {
+            const eventDetail = {
+                element: element,
+                lastPrefetchedImageId: imageId,
+            };
+            (0,esm.triggerEvent)(esm.eventTarget, enums.Events.STACK_PREFETCH_COMPLETE, eventDetail);
+        }
     }
     let lowerIndex = nearest.low;
     let higherIndex = nearest.high;
@@ -8035,6 +8043,7 @@ const stackPrefetch = { enable: stackPrefetch_enable, disable: stackPrefetch_dis
 
 
 
+
 const { imageRetrieveMetadataProvider: stackContextPrefetch_imageRetrieveMetadataProvider } = esm.utilities;
 let stackContextPrefetch_configuration = {
     maxImagesToPrefetch: Infinity,
@@ -8139,6 +8148,13 @@ function stackContextPrefetch_prefetch(element, priority = 0) {
                 }
             }
         }
+        if (stackPrefetch.indicesToRequest.length === 0) {
+            const eventDetail = {
+                element: element,
+                lastPrefetchedImageId: imageId,
+            };
+            (0,esm.triggerEvent)(esm.eventTarget, enums.Events.STACK_PREFETCH_COMPLETE, eventDetail);
+        }
     }
     const requestFn = (imageId, options) => {
         const { retrieveOptions = {} } = esm.metaData.get(stackContextPrefetch_imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, imageId, 'stack') || {};
@@ -10407,6 +10423,9 @@ var base = __webpack_require__(85817);
 class PanTool extends base/* BaseTool */.oS {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            limitToViewport: false,
+        },
     }) {
         super(toolProps, defaultToolProps);
     }
@@ -10416,17 +10435,77 @@ class PanTool extends base/* BaseTool */.oS {
     mouseDragCallback(evt) {
         this._dragCallback(evt);
     }
+    _checkImageInViewport(viewport, deltaPointsCanvas) {
+        const { canvas } = viewport;
+        const ratio = window.devicePixelRatio;
+        const viewportLeft = 0;
+        const viewportRight = canvas.width / ratio;
+        const viewportTop = 0;
+        const viewportBottom = canvas.height / ratio;
+        const defaultActor = viewport.getDefaultActor();
+        const renderer = viewport.getRenderer();
+        let bounds;
+        if (defaultActor && esm.utilities.isImageActor(defaultActor)) {
+            const imageData = defaultActor.actor.getMapper().getInputData();
+            bounds = imageData.getBounds();
+        }
+        else {
+            bounds = renderer.computeVisiblePropBounds();
+        }
+        const [imageLeft, imageTop] = viewport.worldToCanvas([
+            bounds[0],
+            bounds[2],
+            bounds[4],
+        ]);
+        const [imageRight, imageBottom] = viewport.worldToCanvas([
+            bounds[1],
+            bounds[3],
+            bounds[5],
+        ]);
+        const zoom = viewport.getZoom();
+        if (zoom <= 1) {
+            if ((imageLeft + deltaPointsCanvas[0] < viewportLeft &&
+                deltaPointsCanvas[0] < 0) ||
+                (imageRight + deltaPointsCanvas[0] > viewportRight &&
+                    deltaPointsCanvas[0] > 0) ||
+                (imageTop + deltaPointsCanvas[1] < viewportTop &&
+                    deltaPointsCanvas[1] < 0) ||
+                (imageBottom + deltaPointsCanvas[1] > viewportBottom &&
+                    deltaPointsCanvas[1] > 0)) {
+                return false;
+            }
+        }
+        else {
+            if ((imageLeft + deltaPointsCanvas[0] > viewportLeft &&
+                deltaPointsCanvas[0] > 0) ||
+                (imageRight + deltaPointsCanvas[0] < viewportRight &&
+                    deltaPointsCanvas[0] < 0) ||
+                (imageTop + deltaPointsCanvas[1] > viewportTop &&
+                    deltaPointsCanvas[1] > 0) ||
+                (imageBottom + deltaPointsCanvas[1] < viewportBottom &&
+                    deltaPointsCanvas[1] < 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
     _dragCallback(evt) {
         const { element, deltaPoints } = evt.detail;
         const enabledElement = (0,esm.getEnabledElement)(element);
         const deltaPointsWorld = deltaPoints.world;
+        const deltaPointsCanvas = deltaPoints.canvas;
         if (deltaPointsWorld[0] === 0 &&
             deltaPointsWorld[1] === 0 &&
             deltaPointsWorld[2] === 0) {
             return;
         }
-        const camera = enabledElement.viewport.getCamera();
+        const viewport = enabledElement.viewport;
+        const camera = viewport.getCamera();
         const { focalPoint, position } = camera;
+        if (this.configuration.limitToViewport &&
+            !this._checkImageInViewport(viewport, deltaPointsCanvas)) {
+            return;
+        }
         const updatedPosition = [
             position[0] - deltaPointsWorld[0],
             position[1] - deltaPointsWorld[1],
@@ -10437,11 +10516,11 @@ class PanTool extends base/* BaseTool */.oS {
             focalPoint[1] - deltaPointsWorld[1],
             focalPoint[2] - deltaPointsWorld[2],
         ];
-        enabledElement.viewport.setCamera({
+        viewport.setCamera({
             focalPoint: updatedFocalPoint,
             position: updatedPosition,
         });
-        enabledElement.viewport.render();
+        viewport.render();
     }
 }
 PanTool.toolName = 'Pan';
@@ -20271,68 +20350,79 @@ class EllipticalROITool extends base/* AnnotationTool */.EC {
                 pos1Index[0] = Math.floor(pos1Index[0]);
                 pos1Index[1] = Math.floor(pos1Index[1]);
                 pos1Index[2] = Math.floor(pos1Index[2]);
-                const post2Index = EllipticalROITool_transformWorldToIndex(imageData, worldPos2);
-                post2Index[0] = Math.floor(post2Index[0]);
-                post2Index[1] = Math.floor(post2Index[1]);
-                post2Index[2] = Math.floor(post2Index[2]);
-                this.isHandleOutsideImage = !this._isInsideVolume(pos1Index, post2Index, dimensions);
-                const iMin = Math.min(pos1Index[0], post2Index[0]);
-                const iMax = Math.max(pos1Index[0], post2Index[0]);
-                const jMin = Math.min(pos1Index[1], post2Index[1]);
-                const jMax = Math.max(pos1Index[1], post2Index[1]);
-                const kMin = Math.min(pos1Index[2], post2Index[2]);
-                const kMax = Math.max(pos1Index[2], post2Index[2]);
-                const boundsIJK = [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ];
-                const center = [
-                    (topLeftWorld[0] + bottomRightWorld[0]) / 2,
-                    (topLeftWorld[1] + bottomRightWorld[1]) / 2,
-                    (topLeftWorld[2] + bottomRightWorld[2]) / 2,
-                ];
-                const ellipseObj = {
-                    center,
-                    xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-                    yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-                    zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-                };
-                const { worldWidth, worldHeight } = (0,getWorldWidthAndHeightFromTwoPoints/* default */.A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                const handles = [pos1Index, post2Index];
-                const { scale, areaUnit } = (0,getCalibratedUnits/* getCalibratedLengthUnitsAndScale */.Op)(image, handles);
-                const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-                    scale /
-                    scale;
-                const pixelUnitsOptions = {
-                    isPreScaled: (0,isViewportPreScaled/* isViewportPreScaled */.u)(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const modalityUnit = (0,getPixelValueUnits/* getPixelValueUnits */.j)(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
-                let pointsInShape;
-                if (voxelManager) {
-                    const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
-                        boundsIJK,
-                        imageData,
-                        isInObject: (pointLPS) => (0,ellipse.pointInEllipse)(ellipseObj, pointLPS, { fast: true }),
-                        returnPoints: this.configuration.storePointData,
-                    });
+                const pos2Index = EllipticalROITool_transformWorldToIndex(imageData, worldPos2);
+                pos2Index[0] = Math.floor(pos2Index[0]);
+                pos2Index[1] = Math.floor(pos2Index[1]);
+                pos2Index[2] = Math.floor(pos2Index[2]);
+                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
+                    const iMin = Math.min(pos1Index[0], pos2Index[0]);
+                    const iMax = Math.max(pos1Index[0], pos2Index[0]);
+                    const jMin = Math.min(pos1Index[1], pos2Index[1]);
+                    const jMax = Math.max(pos1Index[1], pos2Index[1]);
+                    const kMin = Math.min(pos1Index[2], pos2Index[2]);
+                    const kMax = Math.max(pos1Index[2], pos2Index[2]);
+                    const boundsIJK = [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ];
+                    const center = [
+                        (topLeftWorld[0] + bottomRightWorld[0]) / 2,
+                        (topLeftWorld[1] + bottomRightWorld[1]) / 2,
+                        (topLeftWorld[2] + bottomRightWorld[2]) / 2,
+                    ];
+                    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
+                    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
+                    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
+                    const ellipseObj = {
+                        center,
+                        xRadius: xRadius < esm.EPSILON / 2 ? 0 : xRadius,
+                        yRadius: yRadius < esm.EPSILON / 2 ? 0 : yRadius,
+                        zRadius: zRadius < esm.EPSILON / 2 ? 0 : zRadius,
+                    };
+                    const { worldWidth, worldHeight } = (0,getWorldWidthAndHeightFromTwoPoints/* default */.A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+                    const handles = [pos1Index, pos2Index];
+                    const { scale, unit, areaUnit } = (0,getCalibratedUnits/* getCalibratedLengthUnitsAndScale */.Op)(image, handles);
+                    const aspect = (0,getCalibratedUnits/* getCalibratedAspect */.CQ)(image);
+                    const area = Math.abs(Math.PI *
+                        (worldWidth / scale / 2) *
+                        (worldHeight / aspect / scale / 2));
+                    const pixelUnitsOptions = {
+                        isPreScaled: (0,isViewportPreScaled/* isViewportPreScaled */.u)(viewport, targetId),
+                        isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                    };
+                    const modalityUnit = (0,getPixelValueUnits/* getPixelValueUnits */.j)(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    let pointsInShape;
+                    if (voxelManager) {
+                        pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                            isInObject: (pointLPS) => (0,ellipse.pointInEllipse)(ellipseObj, pointLPS, { fast: true }),
+                            boundsIJK,
+                            imageData,
+                            returnPoints: this.configuration.storePointData,
+                        });
+                    }
+                    const stats = this.configuration.statsCalculator.getStatistics();
+                    cachedStats[targetId] = {
+                        Modality: metadata.Modality,
+                        area,
+                        mean: stats.mean?.value,
+                        max: stats.max?.value,
+                        min: stats.min?.value,
+                        stdDev: stats.stdDev?.value,
+                        statsArray: stats.array,
+                        pointsInShape,
+                        isEmptyArea,
+                        areaUnit,
+                        modalityUnit,
+                    };
+                }
+                else {
+                    this.isHandleOutsideImage = true;
+                    cachedStats[targetId] = {
+                        Modality: metadata.Modality,
+                    };
                 }
-                const stats = this.configuration.statsCalculator.getStatistics();
-                cachedStats[targetId] = {
-                    Modality: metadata.Modality,
-                    area,
-                    mean: stats.mean?.value,
-                    max: stats.max?.value,
-                    min: stats.min?.value,
-                    stdDev: stats.stdDev?.value,
-                    statsArray: stats.array,
-                    pointsInShape,
-                    isEmptyArea,
-                    areaUnit,
-                    modalityUnit,
-                };
             }
             const invalidated = annotation.invalidated;
             annotation.invalidated = false;
@@ -29054,6 +29144,7 @@ class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool/
         esm.eventTarget.addEventListener(enums.Events.ANNOTATION_COMPLETED, this.annotationCompleted);
         esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAddedToToolGroupBinded);
         esm.eventTarget.addEventListener(enums.Events.SEGMENTATION_MODIFIED, this.onSegmentationModifiedBinded);
+        esm.eventTarget.addEventListener(enums.Events.SEGMENTATION_REPRESENTATION_MODIFIED, this.onSegmentationModifiedBinded);
     }
     cleanUpListeners() {
         LabelMapEditWithContourTool.annotationsToViewportMap.clear();
@@ -29062,6 +29153,7 @@ class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool/
         esm.eventTarget.removeEventListener(enums.Events.ANNOTATION_COMPLETED, this.annotationCompleted);
         esm.eventTarget.removeEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAddedToToolGroup.bind(this));
         esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_MODIFIED, this.onSegmentationModified.bind(this));
+        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_REPRESENTATION_MODIFIED, this.onSegmentationModified.bind(this));
     }
     async checkContourSegmentation(viewportId) {
         if (LabelMapEditWithContourTool.viewportIdsChecked.includes(viewportId)) {
@@ -36672,6 +36764,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         },
     }) {
         super(toolProps, defaultToolProps);
+        this._lastDragInfo = null;
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -36683,14 +36776,24 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
-            const { element } = eventData;
+            const { element, currentPoints } = eventData;
             const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
             this._editData = this.createEditData(element);
             this._activateDraw(element);
             (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.hideElementCursor)(element);
             evt.preventDefault();
             this._previewData.isDrag = false;
             this._previewData.timerStart = Date.now();
+            const canvasPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.clone */ .Zc.clone(currentPoints.canvas);
+            const worldPoint = viewport.canvasToWorld([
+                canvasPoint[0],
+                canvasPoint[1],
+            ]);
+            this._lastDragInfo = {
+                canvas: canvasPoint,
+                world: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(worldPoint),
+            };
             const hoverData = this._hoverData || this.createHoverData(element);
             (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
@@ -36765,6 +36868,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
             const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
             (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(viewportIdsToRender);
@@ -36779,11 +36883,39 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
                 window.clearTimeout(this._previewData.timer);
                 this._previewData.timer = null;
             }
-            this._previewData.preview = this.applyActiveStrategy(enabledElement, this.getOperationData(element));
+            if (!this._lastDragInfo) {
+                const startCanvas = this._previewData.startPoint;
+                const startWorld = viewport.canvasToWorld([
+                    startCanvas[0],
+                    startCanvas[1],
+                ]);
+                this._lastDragInfo = {
+                    canvas: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.clone */ .Zc.clone(startCanvas),
+                    world: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(startWorld),
+                };
+            }
+            const currentCanvas = currentPoints.canvas;
+            const currentWorld = viewport.canvasToWorld([
+                currentCanvas[0],
+                currentCanvas[1],
+            ]);
+            this._hoverData = this.createHoverData(element, currentCanvas);
+            this._calculateCursor(element, currentCanvas);
+            const operationData = this.getOperationData(element);
+            operationData.strokePointsWorld = [
+                gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(this._lastDragInfo.world),
+                gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(currentWorld),
+            ];
+            this._previewData.preview = this.applyActiveStrategy(enabledElement, operationData);
+            const currentCanvasClone = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.clone */ .Zc.clone(currentCanvas);
+            this._lastDragInfo = {
+                canvas: currentCanvasClone,
+                world: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(currentWorld),
+            };
             this._previewData.element = element;
             this._previewData.timerStart = Date.now() + dragTimeMs;
             this._previewData.isDrag = true;
-            this._previewData.startPoint = currentPoints.canvas;
+            this._previewData.startPoint = currentCanvasClone;
         };
         this._endCallback = (evt) => {
             const eventData = evt.detail;
@@ -36798,6 +36930,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.resetElementCursor)(element);
             this.updateCursor(evt);
             this._editData = null;
+            this._lastDragInfo = null;
             this.applyActiveStrategyCallback(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_2__.StrategyCallbacks.OnInteractionEnd);
             if (!this._previewData.isDrag) {
                 this.acceptPreview(element);
@@ -37384,7 +37517,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 /* harmony export */   pB: () => (/* binding */ CIRCLE_STRATEGY),
 /* harmony export */   q: () => (/* binding */ thresholdInsideCircle)
 /* harmony export */ });
-/* unused harmony exports fillOutsideCircle, CIRCLE_THRESHOLD_STRATEGY */
+/* unused harmony exports fillOutsideCircle, CIRCLE_THRESHOLD_STRATEGY, createPointInEllipse */
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15327);
 /* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72282);
@@ -37399,7 +37532,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 
 
 
-const { transformWorldToIndex, isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
+const { transformWorldToIndex, transformIndexToWorld, isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
 function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const [bottom, top, left, right] = canvasCoordinates;
     const topLeft = [left[0], top[1]];
@@ -37408,9 +37541,82 @@ function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const topRight = [right[0], top[1]];
     return [topLeft, bottomRight, bottomLeft, topRight];
 }
+function createCircleCornersForCenter(center, viewUp, viewRight, radius) {
+    const centerVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(center[0], center[1], center[2]);
+    const top = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(top, centerVec, viewUp, radius);
+    const bottom = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottom, centerVec, viewUp, -radius);
+    const right = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(right, centerVec, viewRight, radius);
+    const left = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(left, centerVec, viewRight, -radius);
+    return [
+        bottom,
+        top,
+        left,
+        right,
+    ];
+}
+function createStrokePredicate(centers, radius) {
+    if (!centers.length || radius <= 0) {
+        return null;
+    }
+    const radiusSquared = radius * radius;
+    const centerVecs = centers.map((point) => [point[0], point[1], point[2]]);
+    const segments = [];
+    for (let i = 1; i < centerVecs.length; i++) {
+        const start = centerVecs[i - 1];
+        const end = centerVecs[i];
+        const dx = end[0] - start[0];
+        const dy = end[1] - start[1];
+        const dz = end[2] - start[2];
+        const lengthSquared = dx * dx + dy * dy + dz * dz;
+        segments.push({ start, vector: [dx, dy, dz], lengthSquared });
+    }
+    return (worldPoint) => {
+        if (!worldPoint) {
+            return false;
+        }
+        for (const centerVec of centerVecs) {
+            const dx = worldPoint[0] - centerVec[0];
+            const dy = worldPoint[1] - centerVec[1];
+            const dz = worldPoint[2] - centerVec[2];
+            if (dx * dx + dy * dy + dz * dz <= radiusSquared) {
+                return true;
+            }
+        }
+        for (const { start, vector, lengthSquared } of segments) {
+            if (lengthSquared === 0) {
+                const dx = worldPoint[0] - start[0];
+                const dy = worldPoint[1] - start[1];
+                const dz = worldPoint[2] - start[2];
+                if (dx * dx + dy * dy + dz * dz <= radiusSquared) {
+                    return true;
+                }
+                continue;
+            }
+            const dx = worldPoint[0] - start[0];
+            const dy = worldPoint[1] - start[1];
+            const dz = worldPoint[2] - start[2];
+            const dot = dx * vector[0] + dy * vector[1] + dz * vector[2];
+            const t = Math.max(0, Math.min(1, dot / lengthSquared));
+            const projX = start[0] + vector[0] * t;
+            const projY = start[1] + vector[1] * t;
+            const projZ = start[2] + vector[2] * t;
+            const distX = worldPoint[0] - projX;
+            const distY = worldPoint[1] - projY;
+            const distZ = worldPoint[2] - projZ;
+            if (distX * distX + distY * distY + distZ * distZ <= radiusSquared) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
 const initializeCircle = {
     [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, viewport, segmentationImageData, } = operationData;
+        const { points, viewport, segmentationImageData, viewUp, viewPlaneNormal, } = operationData;
         if (!points) {
             return;
         }
@@ -37424,18 +37630,35 @@ const initializeCircle = {
         }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const brushRadius = points.length >= 2 ? gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .eR.distance(points[0], points[1]) / 2 : 0;
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
         const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
         const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
-        const circleCornersIJK = points.map((world) => {
-            return transformWorldToIndex(segmentationImageData, world);
-        });
+        const normalizedViewUp = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(viewUp[0], viewUp[1], viewUp[2]);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(normalizedViewUp, normalizedViewUp);
+        const normalizedPlaneNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(viewPlaneNormal[0], viewPlaneNormal[1], viewPlaneNormal[2]);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(normalizedPlaneNormal, normalizedPlaneNormal);
+        const viewRight = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(viewRight, normalizedViewUp, normalizedPlaneNormal);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(viewRight, viewRight);
+        const strokeCentersSource = operationData.strokePointsWorld &&
+            operationData.strokePointsWorld.length > 0
+            ? operationData.strokePointsWorld
+            : [operationData.centerWorld];
+        const strokeCenters = strokeCentersSource.map((point) => gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.clone */ .eR.clone(point));
+        const strokeCornersWorld = strokeCenters.flatMap((centerPoint) => createCircleCornersForCenter(centerPoint, normalizedViewUp, viewRight, brushRadius));
+        const circleCornersIJK = strokeCornersWorld.map((world) => transformWorldToIndex(segmentationImageData, world));
         const boundsIJK = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__.getBoundingBoxAroundShapeIJK)(circleCornersIJK, segmentationImageData.getDimensions());
-        operationData.isInObject = createPointInEllipse(cornersInWorld);
+        operationData.strokePointsWorld = strokeCenters;
+        operationData.isInObject = createPointInEllipse(cornersInWorld, {
+            strokePointsWorld: strokeCenters,
+            segmentationImageData,
+            radius: brushRadius,
+        });
         operationData.isInObjectBoundsIJK = boundsIJK;
     },
 };
-function createPointInEllipse(cornersInWorld = []) {
+function createPointInEllipse(cornersInWorld = [], options = {}) {
     if (!cornersInWorld || cornersInWorld.length !== 4) {
         throw new Error('createPointInEllipse: cornersInWorld must have 4 points');
     }
@@ -37454,6 +37677,8 @@ function createPointInEllipse(cornersInWorld = []) {
     const normal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
     gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(normal, majorAxisVec, minorAxisVec);
     gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(normal, normal);
+    const radiusForStroke = options.radius ?? Math.max(xRadius, yRadius);
+    const strokePredicate = createStrokePredicate(options.strokePointsWorld || [], radiusForStroke);
     if (isEqual(xRadius, yRadius)) {
         const radius = xRadius;
         const sphereObj = {
@@ -37461,11 +37686,33 @@ function createPointInEllipse(cornersInWorld = []) {
             radius,
             radius2: radius * radius,
         };
-        return (pointLPS) => (0,_utilities_math_sphere__WEBPACK_IMPORTED_MODULE_6__/* .pointInSphere */ .d)(sphereObj, pointLPS);
+        return (pointLPS, pointIJK) => {
+            let worldPoint = pointLPS;
+            if (!worldPoint && pointIJK && options.segmentationImageData) {
+                worldPoint = transformIndexToWorld(options.segmentationImageData, pointIJK);
+            }
+            if (!worldPoint) {
+                return false;
+            }
+            if (strokePredicate?.(worldPoint)) {
+                return true;
+            }
+            return (0,_utilities_math_sphere__WEBPACK_IMPORTED_MODULE_6__/* .pointInSphere */ .d)(sphereObj, worldPoint);
+        };
     }
-    return (pointLPS) => {
+    return (pointLPS, pointIJK) => {
+        let worldPoint = pointLPS;
+        if (!worldPoint && pointIJK && options.segmentationImageData) {
+            worldPoint = transformIndexToWorld(options.segmentationImageData, pointIJK);
+        }
+        if (!worldPoint) {
+            return false;
+        }
+        if (strokePredicate?.(worldPoint)) {
+            return true;
+        }
         const pointVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
-        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(pointVec, pointLPS, center);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(pointVec, worldPoint, center);
         const distToPlane = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(pointVec, normal);
         const proj = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
         gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(proj, pointVec, normal, -distToPlane);

package/dist/{app.bundle.7ea0ea630b0467e32f40.js → app.bundle.3759d6a4606059b97022.js}

@@ -44223,7 +44223,7 @@ function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILU
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ version)
 /* harmony export */ });
-const version = '4.3.14';
+const version = '4.5.3';
 
 
 /***/ }),
@@ -48335,8 +48335,15 @@ function metaDataProvider_metaDataProvider(type, imageId) {
         return getTransferSyntax(imageId, metaData);
     }
     if (type === MetadataModules.PET_SERIES) {
+        let correctedImageData = metaData['00280051'];
+        let correctedImage = metaData_getValue(metaData['00280051']);
+        if (correctedImageData &&
+            correctedImageData.Value &&
+            Array.isArray(correctedImageData.Value)) {
+            correctedImage = correctedImageData.Value.join('\\');
+        }
         return {
-            correctedImage: metaData_getValue(metaData['00280051']),
+            correctedImage,
             units: metaData_getValue(metaData['00541001']),
             decayCorrection: metaData_getValue(metaData['00541102']),
         };
@@ -135421,7 +135428,7 @@ const detectionOptions = {
   }
 });
 ;// ../../i18n/package.json
-const package_namespaceObject = /*#__PURE__*/JSON.parse('{"rE":"3.12.0-beta.51"}');
+const package_namespaceObject = /*#__PURE__*/JSON.parse('{"rE":"3.12.0-beta.53"}');
 ;// ../../i18n/src/utils.js
 const languagesMap = {
   ar: 'Arabic',
@@ -386133,7 +386140,7 @@ function __rewriteRelativeImportExtension(path, preserveJsx) {
 /******/ 		// This function allow to reference async chunks
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + ({"572":"polySeg","2007":"interpolation","3054":"histogram-worker","3694":"compute"}[chunkId] || chunkId) + ".bundle." + {"85":"72ca9e62d8bcef003e42","147":"30b16832e09898deaf32","213":"844009eea53b5e7b71bf","319":"fc959064ddf2f6978b54","414":"113bc87916aa22d4cccc","572":"1ab7dd310985596b4098","732":"6978ac30a1e36abf06db","810":"04da3bf08f7df9589091","934":"d028841173058da9793c","1447":"f58681b8a8c6746c3256","1459":"26bd313381a55ecd59f7","1604":"813a49f279de52122def","1807":"9609cc9a5502d3c5c4ba","1919":"b1390ab4c85106c069e2","1927":"8941122be98d6aea153c","2007":"f58dd6d3d25dd22cfefd","2108":"e84aa8d858d8c4f2413e","2243":"92d2afd8756bda5e2ca3","2345":"839224623fb00f805981","2424":"d3c0fa7cda17e7a40fc9","2518":"fbbfa351f8e8c446599b","2701":"3c34bd7d28cb2d095a5c","2974":"ec95e58b346dbe30a362","3054":"b7bb02c6cd9273c422f5","3409":"c756a8ccaa7faa1d9235","3694":"f176731b761d630f358c","4019":"c5b332003e3cd00868ce","4113":"31fe4e2a2956ce6c5d2d","4202":"1cef28d8aec1155d35d1","4759":"8686abdd7bcf4aa7d107","5261":"6e1a017f8f1027557f5b","5349":"44217fe4d4ce9a3a9be3","5457":"1d6b074af89e69a54dde","5485":"ae87fca794a3248efdaa","5674":"24de237ef15879b25714","5802":"48b958ebd8d250156814","6027":"2b0e82eb38b6a028a255","6201":"0d8aa2fba299a8cc92a9","6939":"41fbdef87597b5172ec6","6991":"d0c8eb5e352477b0d42e","7159":"122cd4e6d8fd1287d07f","7197":"7cc9bb98050e4ae0294d","7412":"80f68b38041e891c64a8","7431":"f6ee76ae243ffe1c811a","7639":"fb8c61c6588c528d336f","8094":"5c44190a325ac23e3e5c","8402":"edb924cd47cd168f621c","8558":"9ee1f10769f9cac46bb3","8740":"39b40ee21a873e824ce8","8815":"c5c714fe2a3ff31aacad","9862":"1133b0f6bd2b035c85bd"}[chunkId] + ".js";
+/******/ 			return "" + ({"572":"polySeg","2007":"interpolation","3054":"histogram-worker","3694":"compute"}[chunkId] || chunkId) + ".bundle." + {"85":"cc4e5b3a9acca13007a5","147":"30b16832e09898deaf32","213":"d174db20fab2fdfed4f8","319":"fc959064ddf2f6978b54","414":"6f9b2a00f06626f05c27","572":"ba4364ed21d03c7a9df1","732":"6978ac30a1e36abf06db","810":"4f3a7ca74971239c1498","934":"cce2fe2754a928b8cd6d","1447":"b15051ce6a9bcec1ac6a","1459":"d4ef552f8dec2c8b15fc","1604":"ba4b8c8f64d258a40850","1807":"ddc2996069271a8652a5","1919":"7c1b4166b95e7dffe973","1927":"8941122be98d6aea153c","2007":"f58dd6d3d25dd22cfefd","2108":"e84aa8d858d8c4f2413e","2243":"727d1f866dda05467f19","2345":"839224623fb00f805981","2424":"132b9ea62e24599d01f7","2518":"57c229a14e22d23db384","2701":"3c34bd7d28cb2d095a5c","2974":"a90a9df917b90bc02c69","3054":"b7bb02c6cd9273c422f5","3409":"257f7edb1585ea06ba3c","3694":"afdef7ac00941da4dd32","4019":"13e7f662a9e489b74a27","4113":"85916db39290d43aa53b","4202":"1cef28d8aec1155d35d1","4759":"c3bfca952eea20a0d6f9","5261":"6e1a017f8f1027557f5b","5349":"44217fe4d4ce9a3a9be3","5457":"51285f55e1389d654257","5485":"371660cf6663e90cd622","5674":"8c34228471ff9e53b8c3","5802":"48b958ebd8d250156814","6027":"f220a72a6e4232c38a87","6201":"40aca7bfb7513a6ebda7","6939":"41fbdef87597b5172ec6","6991":"48929c562b9d3012e468","7159":"122cd4e6d8fd1287d07f","7197":"52da128e3f00a7ad7902","7412":"c7950ea929406915ba33","7431":"f6ee76ae243ffe1c811a","7639":"1226ddb2bc46f5cae750","8094":"5c44190a325ac23e3e5c","8402":"edb924cd47cd168f621c","8558":"9f596952dd6a5fa6f629","8740":"39b40ee21a873e824ce8","8815":"525c88f93f5bd57e4980","9862":"1133b0f6bd2b035c85bd"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/