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

package/dist/{9856.bundle.8e21e8c0322a0837862b.js → 9856.bundle.9a1396fddc3af67dcaf4.js}

@@ -8724,6 +8724,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         },
     }) {
         super(toolProps, defaultToolProps);
+        this._lastDragInfo = null;
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -8735,14 +8736,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);
@@ -8817,6 +8828,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);
@@ -8831,11 +8843,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;
@@ -8850,6 +8890,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);
@@ -9042,7 +9083,7 @@ BrushTool.toolName = 'Brush';
 /* 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);
@@ -9057,7 +9098,7 @@ BrushTool.toolName = 'Brush';
 
 
 
-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]];
@@ -9066,9 +9107,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;
         }
@@ -9082,18 +9196,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');
     }
@@ -9112,6 +9243,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 = {
@@ -9119,11 +9252,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);