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

package/dist/{9892.bundle.83de6c11c8a9eb4bba25.js → 9892.bundle.f00828c8f4763b097271.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.1';
 
 ;// ../../../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') || {};
@@ -20271,68 +20287,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;
@@ -36672,6 +36699,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         },
     }) {
         super(toolProps, defaultToolProps);
+        this._lastDragInfo = null;
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -36683,14 +36711,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 +36803,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 +36818,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 +36865,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 +37452,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 +37467,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 +37476,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 +37565,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 +37612,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 +37621,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.b5c364b2112dc6c8fef1.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.1';
 
 
 /***/ }),
@@ -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.52"}');
 ;// ../../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":"a84605c91fb325b762dd","147":"30b16832e09898deaf32","213":"32923830428c6ce36969","319":"fc959064ddf2f6978b54","414":"2812dfdd9dcbf5ec54f4","572":"99fe77d122f62107b12e","732":"6978ac30a1e36abf06db","810":"c1486b31c437a41ef7ce","934":"f62759c74362ecd45046","1447":"ec55b67e67336fc21395","1459":"9803b32f90cade8bbab5","1604":"82b3545ba77291673ab0","1807":"52567533b273a2581fe6","1919":"4e6bd406f3e744fac297","1927":"8941122be98d6aea153c","2007":"f58dd6d3d25dd22cfefd","2108":"e84aa8d858d8c4f2413e","2243":"d37af11011d841506650","2345":"839224623fb00f805981","2424":"c757e549b61768f3907f","2518":"57c229a14e22d23db384","2701":"3c34bd7d28cb2d095a5c","2974":"a90a9df917b90bc02c69","3054":"b7bb02c6cd9273c422f5","3409":"fdd66303b88b09df1755","3694":"957cf6f00e6c9f033f51","4019":"13e7f662a9e489b74a27","4113":"8aa17598a438e0f59977","4202":"1cef28d8aec1155d35d1","4759":"c3bfca952eea20a0d6f9","5261":"6e1a017f8f1027557f5b","5349":"44217fe4d4ce9a3a9be3","5457":"a34aefc642710f3c4bfe","5485":"6a30e022e40ee4efcf64","5674":"8c34228471ff9e53b8c3","5802":"48b958ebd8d250156814","6027":"13ce9445760aecded831","6201":"1449ec26ca43420a516a","6939":"41fbdef87597b5172ec6","6991":"80eea6ff61dba94b2879","7159":"122cd4e6d8fd1287d07f","7197":"20b8564f4a4af9191bef","7412":"42d0b84eb71e17deea44","7431":"f6ee76ae243ffe1c811a","7639":"6988d6e467128811633c","8094":"5c44190a325ac23e3e5c","8402":"edb924cd47cd168f621c","8558":"7b39c27e2bd32e4a18aa","8740":"39b40ee21a873e824ce8","8815":"9531838f1288ab88a108","9862":"1133b0f6bd2b035c85bd"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/ 	

package/dist/{compute.bundle.f176731b761d630f358c.js → compute.bundle.957cf6f00e6c9f033f51.js}

@@ -136,7 +136,7 @@
 /******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + (chunkId === 3694 ? "compute" : chunkId) + ".bundle." + {"573":"a00b1c9a43f933c220ec","2345":"839224623fb00f805981","3694":"f176731b761d630f358c","4019":"c5b332003e3cd00868ce","9819":"f9a684737e748002f1c2","9856":"8e21e8c0322a0837862b"}[chunkId] + ".js";
+/******/ 			return "" + (chunkId === 3694 ? "compute" : chunkId) + ".bundle." + {"573":"a00b1c9a43f933c220ec","2345":"839224623fb00f805981","3694":"957cf6f00e6c9f033f51","4019":"13e7f662a9e489b74a27","9819":"cb36094b2dbfe6332e89","9856":"9a1396fddc3af67dcaf4"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/ 	

package/dist/index.html

@@ -3,4 +3,4 @@
         return import(moduleId);
       }
 
-      window.PUBLIC_URL = '/';</script><script defer="defer" src="/app.bundle.7ea0ea630b0467e32f40.js"></script><link href="/app.bundle.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="react-portal"></div><div id="root"></div></body></html>
+      window.PUBLIC_URL = '/';</script><script defer="defer" src="/app.bundle.b5c364b2112dc6c8fef1.js"></script><link href="/app.bundle.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="react-portal"></div><div id="root"></div></body></html>

package/dist/{polySeg.bundle.1ab7dd310985596b4098.js → polySeg.bundle.99fe77d122f62107b12e.js}

@@ -136,7 +136,7 @@
 /******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + (chunkId === 3694 ? "compute" : chunkId) + ".bundle." + {"319":"fc959064ddf2f6978b54","573":"a00b1c9a43f933c220ec","3694":"f176731b761d630f358c","4019":"c5b332003e3cd00868ce","7758":"c8d106364298e7d288f0","9819":"f9a684737e748002f1c2","9892":"83de6c11c8a9eb4bba25"}[chunkId] + ".js";
+/******/ 			return "" + (chunkId === 3694 ? "compute" : chunkId) + ".bundle." + {"319":"fc959064ddf2f6978b54","573":"a00b1c9a43f933c220ec","3694":"957cf6f00e6c9f033f51","4019":"13e7f662a9e489b74a27","7758":"c8d106364298e7d288f0","9819":"cb36094b2dbfe6332e89","9892":"f00828c8f4763b097271"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/