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

package/dist/{7412.bundle.80f68b38041e891c64a8.js → 7412.bundle.c7950ea929406915ba33.js}

@@ -3348,9 +3348,11 @@ class FrameOfReferenceSpecificAnnotationManager {
             }
             if (toolName) {
                 const annotationsForTool = annotations[groupKey][toolName];
-                for (const annotation of annotationsForTool) {
-                    this.removeAnnotation(annotation.annotationUID);
-                    removedAnnotations.push(annotation);
+                if (annotationsForTool) {
+                    for (const annotation of annotationsForTool) {
+                        this.removeAnnotation(annotation.annotationUID);
+                        removedAnnotations.push(annotation);
+                    }
                 }
             }
             else {
@@ -12163,6 +12165,9 @@ OverlayGridTool.toolName = 'OverlayGrid';
 class PanTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .BaseTool */ .oS {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            limitToViewport: false,
+        },
     }) {
         super(toolProps, defaultToolProps);
     }
@@ -12172,17 +12177,77 @@ class PanTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .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 && _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.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,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.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],
@@ -12193,11 +12258,11 @@ class PanTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .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';
@@ -21442,68 +21507,79 @@ class EllipticalROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .Annotation
                 pos1Index[0] = Math.floor(pos1Index[0]);
                 pos1Index[1] = Math.floor(pos1Index[1]);
                 pos1Index[2] = Math.floor(pos1Index[2]);
-                const post2Index = 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,_utilities_planar_getWorldWidthAndHeightFromTwoPoints__WEBPACK_IMPORTED_MODULE_13__/* ["default"] */ .A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                const handles = [pos1Index, post2Index];
-                const { scale, areaUnit } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles);
-                const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-                    scale /
-                    scale;
-                const pixelUnitsOptions = {
-                    isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_18__/* .isViewportPreScaled */ .u)(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const modalityUnit = (0,_utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_17__/* .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,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_14__.pointInEllipse)(ellipseObj, pointLPS, { fast: true }),
-                        returnPoints: this.configuration.storePointData,
-                    });
+                const pos2Index = 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 < _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.EPSILON / 2 ? 0 : xRadius,
+                        yRadius: yRadius < _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.EPSILON / 2 ? 0 : yRadius,
+                        zRadius: zRadius < _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.EPSILON / 2 ? 0 : zRadius,
+                    };
+                    const { worldWidth, worldHeight } = (0,_utilities_planar_getWorldWidthAndHeightFromTwoPoints__WEBPACK_IMPORTED_MODULE_13__/* ["default"] */ .A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+                    const handles = [pos1Index, pos2Index];
+                    const { scale, unit, areaUnit } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles);
+                    const aspect = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedAspect */ .CQ)(image);
+                    const area = Math.abs(Math.PI *
+                        (worldWidth / scale / 2) *
+                        (worldHeight / aspect / scale / 2));
+                    const pixelUnitsOptions = {
+                        isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_18__/* .isViewportPreScaled */ .u)(viewport, targetId),
+                        isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                    };
+                    const modalityUnit = (0,_utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_17__/* .getPixelValueUnits */ .j)(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    let pointsInShape;
+                    if (voxelManager) {
+                        pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                            isInObject: (pointLPS) => (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_14__.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;
@@ -29996,6 +30072,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         },
     }) {
         super(toolProps, defaultToolProps);
+        this._lastDragInfo = null;
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -30007,14 +30084,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);
@@ -30089,6 +30176,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);
@@ -30103,11 +30191,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;
@@ -30122,6 +30238,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);
@@ -31152,6 +31269,7 @@ class LabelMapEditWithContourTool extends _annotation_PlanarFreehandContourSegme
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.ANNOTATION_COMPLETED, this.annotationCompleted);
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAddedToToolGroupBinded);
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.SEGMENTATION_MODIFIED, this.onSegmentationModifiedBinded);
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.SEGMENTATION_REPRESENTATION_MODIFIED, this.onSegmentationModifiedBinded);
     }
     cleanUpListeners() {
         LabelMapEditWithContourTool.annotationsToViewportMap.clear();
@@ -31160,6 +31278,7 @@ class LabelMapEditWithContourTool extends _annotation_PlanarFreehandContourSegme
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.ANNOTATION_COMPLETED, this.annotationCompleted);
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAddedToToolGroup.bind(this));
         _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.SEGMENTATION_MODIFIED, this.onSegmentationModified.bind(this));
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.SEGMENTATION_REPRESENTATION_MODIFIED, this.onSegmentationModified.bind(this));
     }
     async checkContourSegmentation(viewportId) {
         if (LabelMapEditWithContourTool.viewportIdsChecked.includes(viewportId)) {
@@ -33307,7 +33426,7 @@ SphereScissorsTool.toolName = 'SphereScissor';
 /* harmony export */   pB: () => (/* binding */ CIRCLE_STRATEGY),
 /* harmony export */   q: () => (/* binding */ thresholdInsideCircle)
 /* harmony export */ });
-/* unused harmony export CIRCLE_THRESHOLD_STRATEGY */
+/* unused harmony exports 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);
@@ -33322,7 +33441,7 @@ SphereScissorsTool.toolName = 'SphereScissor';
 
 
 
-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]];
@@ -33331,9 +33450,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;
         }
@@ -33347,18 +33539,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');
     }
@@ -33377,6 +33586,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 = {
@@ -33384,11 +33595,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);
@@ -35075,14 +35308,21 @@ function addSegmentInSegmentation(segmentation, { segmentIndex, label, color })
     if (!segmentation?.segments) {
         return;
     }
-    segmentation.segments[segmentIndex] = {
+    const segmentData = segmentation.segments[segmentIndex] ?? {
         active: false,
         locked: false,
-        label,
         segmentIndex,
         cachedStats: {},
+        label,
         color,
     };
+    if (label !== undefined) {
+        segmentData.label = label;
+    }
+    if (color !== undefined) {
+        segmentData.color = color;
+    }
+    segmentation.segments[segmentIndex] = segmentData;
 }
 function removeAnnotations(annotationUIDList) {
     annotationUIDList.forEach((annotationUID) => {
@@ -42353,6 +42593,8 @@ function setAnnotationLabel(annotation, element, updatedLabel) {
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30045);
 /* harmony import */ var _stackPrefetchUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(94762);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99737);
+
 
 
 
@@ -42460,6 +42702,13 @@ function prefetch(element, priority = 0) {
                 }
             }
         }
+        if (stackPrefetch.indicesToRequest.length === 0) {
+            const eventDetail = {
+                element: element,
+                lastPrefetchedImageId: imageId,
+            };
+            (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_3__.Events.STACK_PREFETCH_COMPLETE, eventDetail);
+        }
     }
     const requestFn = (imageId, options) => {
         const { retrieveOptions = {} } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, imageId, 'stack') || {};
@@ -42597,6 +42846,8 @@ const stackContextPrefetch = {
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30045);
 /* harmony import */ var _stackPrefetchUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(94762);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99737);
+
 
 
 
@@ -42659,6 +42910,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,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_3__.Events.STACK_PREFETCH_COMPLETE, eventDetail);
+        }
     }
     let lowerIndex = nearest.low;
     let higherIndex = nearest.high;
@@ -43798,7 +44056,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ version)
 /* harmony export */ });
-const version = '4.3.14';
+const version = '4.5.3';
 
 
 /***/ }),

package/dist/{8558.bundle.9ee1f10769f9cac46bb3.js → 8558.bundle.9f596952dd6a5fa6f629.js}

@@ -39,6 +39,7 @@ var Events;
     Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
     Events["VOLUMECROPPINGCONTROL_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED";
     Events["VOLUMECROPPING_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED";
+    Events["STACK_PREFETCH_COMPLETE"] = "CORNERSTONE_TOOLS_STACK_PREFETCH_COMPLETE";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";

package/dist/{934.bundle.d028841173058da9793c.js → 934.bundle.cce2fe2754a928b8cd6d.js}

@@ -39,6 +39,7 @@ var Events;
     Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
     Events["VOLUMECROPPINGCONTROL_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED";
     Events["VOLUMECROPPING_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED";
+    Events["STACK_PREFETCH_COMPLETE"] = "CORNERSTONE_TOOLS_STACK_PREFETCH_COMPLETE";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";