@cornerstonejs/tools 4.4.1 → 4.5.0

package/dist/esm/tools/annotation/EllipticalROITool.js

@@ -1,6 +1,6 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
-import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
+import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -535,68 +535,79 @@ class EllipticalROITool extends AnnotationTool {
                 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 } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                const handles = [pos1Index, post2Index];
-                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
-                const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-                    scale /
-                    scale;
-                const pixelUnitsOptions = {
-                    isPreScaled: isViewportPreScaled(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
-                let pointsInShape;
-                if (voxelManager) {
-                    const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
-                        boundsIJK,
-                        imageData,
-                        isInObject: (pointLPS) => 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 < EPSILON / 2 ? 0 : xRadius,
+                        yRadius: yRadius < EPSILON / 2 ? 0 : yRadius,
+                        zRadius: zRadius < EPSILON / 2 ? 0 : zRadius,
+                    };
+                    const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+                    const handles = [pos1Index, pos2Index];
+                    const { scale, unit, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const aspect = getCalibratedAspect(image);
+                    const area = Math.abs(Math.PI *
+                        (worldWidth / scale / 2) *
+                        (worldHeight / aspect / scale / 2));
+                    const pixelUnitsOptions = {
+                        isPreScaled: isViewportPreScaled(viewport, targetId),
+                        isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                    };
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    let pointsInShape;
+                    if (voxelManager) {
+                        pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                            isInObject: (pointLPS) => 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;

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -3,6 +3,7 @@ import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '.
 import LabelmapBaseTool from './LabelmapBaseTool';
 declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
+    private _lastDragInfo;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     onSetToolPassive: (evt: any) => void;
     onSetToolEnabled: () => void;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -80,6 +80,7 @@ class BrushTool extends LabelmapBaseTool {
         },
     }) {
         super(toolProps, defaultToolProps);
+        this._lastDragInfo = null;
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -91,14 +92,24 @@ class BrushTool extends LabelmapBaseTool {
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
-            const { element } = eventData;
+            const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
             this._editData = this.createEditData(element);
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
             this._previewData.isDrag = false;
             this._previewData.timerStart = Date.now();
+            const canvasPoint = vec2.clone(currentPoints.canvas);
+            const worldPoint = viewport.canvasToWorld([
+                canvasPoint[0],
+                canvasPoint[1],
+            ]);
+            this._lastDragInfo = {
+                canvas: canvasPoint,
+                world: vec3.clone(worldPoint),
+            };
             const hoverData = this._hoverData || this.createHoverData(element);
             triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
@@ -173,6 +184,7 @@ class BrushTool extends LabelmapBaseTool {
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
             triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
@@ -187,11 +199,39 @@ class BrushTool extends LabelmapBaseTool {
                 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: vec2.clone(startCanvas),
+                    world: vec3.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 = [
+                vec3.clone(this._lastDragInfo.world),
+                vec3.clone(currentWorld),
+            ];
+            this._previewData.preview = this.applyActiveStrategy(enabledElement, operationData);
+            const currentCanvasClone = vec2.clone(currentCanvas);
+            this._lastDragInfo = {
+                canvas: currentCanvasClone,
+                world: vec3.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;
@@ -206,6 +246,7 @@ class BrushTool extends LabelmapBaseTool {
             resetElementCursor(element);
             this.updateCursor(evt);
             this._editData = null;
+            this._lastDragInfo = null;
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionEnd);
             if (!this._previewData.isDrag) {
                 this.acceptPreview(element);

package/dist/esm/tools/segmentation/strategies/__tests__/fillCircle.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tools/segmentation/strategies/__tests__/fillCircle.spec.js

@@ -0,0 +1,27 @@
+import { createPointInEllipse } from '../fillCircle';
+describe('createPointInEllipse', () => {
+    const corners = [
+        [-1, 1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+        [1, 1, 0],
+    ];
+    it('detects points inside the base circle', () => {
+        const predicate = createPointInEllipse(corners);
+        expect(predicate([0, 0, 0])).toBe(true);
+        expect(predicate([0.5, 0.5, 0])).toBe(true);
+        expect(predicate([1.2, 0, 0])).toBe(false);
+    });
+    it('covers interpolated stroke segments', () => {
+        const predicate = createPointInEllipse(corners, {
+            strokePointsWorld: [
+                [-2, 0, 0],
+                [2, 0, 0],
+            ],
+            radius: 1,
+        });
+        expect(predicate([0, 0, 0])).toBe(true);
+        expect(predicate([1.5, 0, 0])).toBe(true);
+        expect(predicate([3.2, 0, 0])).toBe(false);
+    });
+});

package/dist/esm/tools/segmentation/strategies/fillCircle.d.ts

@@ -1,11 +1,16 @@
 import type { Types } from '@cornerstonejs/core';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import BrushStrategy from './BrushStrategy';
 import type { CanvasCoordinates } from '../../../types';
 export declare function getEllipseCornersFromCanvasCoordinates(canvasCoordinates: CanvasCoordinates): Array<Types.Point2>;
-declare function createPointInEllipse(cornersInWorld?: Types.Point3[]): (pointLPS: Types.Point3) => boolean;
+declare function createPointInEllipse(cornersInWorld?: Types.Point3[], options?: {
+    strokePointsWorld?: Types.Point3[];
+    segmentationImageData?: vtkImageData;
+    radius?: number;
+}): (pointLPS: Types.Point3 | null, pointIJK?: Types.Point3) => boolean;
 declare const CIRCLE_STRATEGY: BrushStrategy;
 declare const CIRCLE_THRESHOLD_STRATEGY: BrushStrategy;
 declare const fillInsideCircle: (enabledElement: any, operationData: any) => unknown;
 declare const thresholdInsideCircle: (enabledElement: any, operationData: any) => unknown;
 export declare function fillOutsideCircle(): void;
-export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse as createEllipseInPoint, };
+export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse, createPointInEllipse as createEllipseInPoint, };

package/dist/esm/tools/segmentation/strategies/fillCircle.js

@@ -5,7 +5,7 @@ import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 import { pointInSphere } from '../../../utilities/math/sphere';
-const { transformWorldToIndex, isEqual } = csUtils;
+const { transformWorldToIndex, transformIndexToWorld, isEqual } = csUtils;
 export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const [bottom, top, left, right] = canvasCoordinates;
     const topLeft = [left[0], top[1]];
@@ -14,9 +14,82 @@ export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
     const topRight = [right[0], top[1]];
     return [topLeft, bottomRight, bottomLeft, topRight];
 }
+function createCircleCornersForCenter(center, viewUp, viewRight, radius) {
+    const centerVec = vec3.fromValues(center[0], center[1], center[2]);
+    const top = vec3.create();
+    vec3.scaleAndAdd(top, centerVec, viewUp, radius);
+    const bottom = vec3.create();
+    vec3.scaleAndAdd(bottom, centerVec, viewUp, -radius);
+    const right = vec3.create();
+    vec3.scaleAndAdd(right, centerVec, viewRight, radius);
+    const left = vec3.create();
+    vec3.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 = {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, viewport, segmentationImageData, } = operationData;
+        const { points, viewport, segmentationImageData, viewUp, viewPlaneNormal, } = operationData;
         if (!points) {
             return;
         }
@@ -30,18 +103,35 @@ const initializeCircle = {
         }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const brushRadius = points.length >= 2 ? vec3.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 = vec3.fromValues(viewUp[0], viewUp[1], viewUp[2]);
+        vec3.normalize(normalizedViewUp, normalizedViewUp);
+        const normalizedPlaneNormal = vec3.fromValues(viewPlaneNormal[0], viewPlaneNormal[1], viewPlaneNormal[2]);
+        vec3.normalize(normalizedPlaneNormal, normalizedPlaneNormal);
+        const viewRight = vec3.create();
+        vec3.cross(viewRight, normalizedViewUp, normalizedPlaneNormal);
+        vec3.normalize(viewRight, viewRight);
+        const strokeCentersSource = operationData.strokePointsWorld &&
+            operationData.strokePointsWorld.length > 0
+            ? operationData.strokePointsWorld
+            : [operationData.centerWorld];
+        const strokeCenters = strokeCentersSource.map((point) => vec3.clone(point));
+        const strokeCornersWorld = strokeCenters.flatMap((centerPoint) => createCircleCornersForCenter(centerPoint, normalizedViewUp, viewRight, brushRadius));
+        const circleCornersIJK = strokeCornersWorld.map((world) => transformWorldToIndex(segmentationImageData, world));
         const boundsIJK = 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');
     }
@@ -60,6 +150,8 @@ function createPointInEllipse(cornersInWorld = []) {
     const normal = vec3.create();
     vec3.cross(normal, majorAxisVec, minorAxisVec);
     vec3.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 = {
@@ -67,11 +159,33 @@ function createPointInEllipse(cornersInWorld = []) {
             radius,
             radius2: radius * radius,
         };
-        return (pointLPS) => pointInSphere(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 pointInSphere(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 = vec3.create();
-        vec3.subtract(pointVec, pointLPS, center);
+        vec3.subtract(pointVec, worldPoint, center);
         const distToPlane = vec3.dot(pointVec, normal);
         const proj = vec3.create();
         vec3.scaleAndAdd(proj, pointVec, normal, -distToPlane);
@@ -91,4 +205,4 @@ const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 export function fillOutsideCircle() {
     throw new Error('Not yet implemented');
 }
-export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse as createEllipseInPoint, };
+export { CIRCLE_STRATEGY, CIRCLE_THRESHOLD_STRATEGY, fillInsideCircle, thresholdInsideCircle, createPointInEllipse, createPointInEllipse as createEllipseInPoint, };

package/dist/esm/tools/segmentation/strategies/fillSphere.js

@@ -22,12 +22,76 @@ const sphereComposition = {
         }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const { boundsIJK: newBoundsIJK } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
+        const baseExtent = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
         const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
         const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
-        operationData.isInObjectBoundsIJK = newBoundsIJK;
-        operationData.isInObject = createEllipseInPoint(cornersInWorld);
+        const strokeRadius = points.length >= 2 ? vec3.distance(points[0], points[1]) / 2 : undefined;
+        const strokeCenters = operationData.strokePointsWorld &&
+            operationData.strokePointsWorld.length > 0
+            ? operationData.strokePointsWorld
+            : [operationData.centerWorld];
+        const baseBounds = baseExtent.boundsIJK;
+        const baseCenterIJK = operationData.centerIJK;
+        const boundsForStroke = strokeCenters.reduce((acc, centerPoint) => {
+            if (!centerPoint) {
+                return acc;
+            }
+            const translatedCenterIJK = transformWorldToIndex(segmentationImageData, centerPoint);
+            const deltaIJK = [
+                translatedCenterIJK[0] - baseCenterIJK[0],
+                translatedCenterIJK[1] - baseCenterIJK[1],
+                translatedCenterIJK[2] - baseCenterIJK[2],
+            ];
+            const translatedBounds = [
+                [baseBounds[0][0] + deltaIJK[0], baseBounds[0][1] + deltaIJK[0]],
+                [baseBounds[1][0] + deltaIJK[1], baseBounds[1][1] + deltaIJK[1]],
+                [baseBounds[2][0] + deltaIJK[2], baseBounds[2][1] + deltaIJK[2]],
+            ];
+            if (!acc) {
+                return translatedBounds;
+            }
+            return [
+                [
+                    Math.min(acc[0][0], translatedBounds[0][0]),
+                    Math.max(acc[0][1], translatedBounds[0][1]),
+                ],
+                [
+                    Math.min(acc[1][0], translatedBounds[1][0]),
+                    Math.max(acc[1][1], translatedBounds[1][1]),
+                ],
+                [
+                    Math.min(acc[2][0], translatedBounds[2][0]),
+                    Math.max(acc[2][1], translatedBounds[2][1]),
+                ],
+            ];
+        }, null);
+        const boundsToUse = boundsForStroke ?? baseExtent.boundsIJK;
+        if (segmentationImageData) {
+            const dimensions = segmentationImageData.getDimensions();
+            operationData.isInObjectBoundsIJK = [
+                [
+                    Math.max(0, Math.min(boundsToUse[0][0], dimensions[0] - 1)),
+                    Math.max(0, Math.min(boundsToUse[0][1], dimensions[0] - 1)),
+                ],
+                [
+                    Math.max(0, Math.min(boundsToUse[1][0], dimensions[1] - 1)),
+                    Math.max(0, Math.min(boundsToUse[1][1], dimensions[1] - 1)),
+                ],
+                [
+                    Math.max(0, Math.min(boundsToUse[2][0], dimensions[2] - 1)),
+                    Math.max(0, Math.min(boundsToUse[2][1], dimensions[2] - 1)),
+                ],
+            ];
+        }
+        else {
+            operationData.isInObjectBoundsIJK = boundsToUse;
+        }
+        operationData.isInObject = createEllipseInPoint(cornersInWorld, {
+            strokePointsWorld: operationData.strokePointsWorld,
+            segmentationImageData,
+            radius: strokeRadius,
+        });
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.ensureSegmentationVolumeFor3DManipulation);

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -12,6 +12,7 @@ type LabelmapToolOperationData = {
     viewUp: number[];
     activeStrategy: string;
     points: Types.Point3[];
+    strokePointsWorld?: Types.Point3[];
     voxelManager: any;
     override: {
         voxelManager: Types.IVoxelManager<number>;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.4.1";
+export declare const version = "4.5.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.4.1';
+export const version = '4.5.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.4.1",
+    "@cornerstonejs/core": "4.5.0",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "a3125cde6a15894c53f1c4e8e7bcd31530b78aaf"
+  "gitHead": "b678e3f34fb4984c6ba94c1564e60b63ae08cd42"
 }