@cornerstonejs/tools 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/esm/tools/WindowLevelTool.js

@@ -143,7 +143,7 @@ class WindowLevelTool extends BaseTool {
             }, [Infinity, -Infinity]);
             const BitsStored = imageVolume?.metadata?.BitsStored;
             const metadataDynamicRange = BitsStored ? 2 ** BitsStored : Infinity;
-            imageDynamicRange = Math.min(calculatedDynamicRange, metadataDynamicRange);
+            imageDynamicRange = Math.min(calculatedDynamicRange[1] - calculatedDynamicRange[0], metadataDynamicRange);
         }
         else {
             imageDynamicRange = this._getImageDynamicRangeFromViewport(viewport);

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

@@ -333,6 +333,7 @@ class ProbeTool extends AnnotationTool {
                     Modality: modality,
                     modalityUnit,
                 };
+                annotation.invalidated = true;
             }
             else {
                 this.isHandleOutsideImage = true;

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/generateConvexHullFromContour.js

@@ -1,6 +1,6 @@
-import { utilities } from '@cornerstonejs/tools';
+import * as math from '../../../../utilities/math';
 export function generateConvexHullFromContour(contour) {
-    const simplified = utilities.math.polyline.decimate(contour, 2);
-    const hull = utilities.math.polyline.convexHull(simplified);
+    const simplified = math.polyline.decimate(contour, 2);
+    const hull = math.polyline.convexHull(simplified);
     return { simplified, hull };
 }

package/dist/esm/tools/annotation/VideoRedactionTool.d.ts

@@ -22,7 +22,7 @@ declare class VideoRedactionTool extends AnnotationTool {
     handleSelectedCallback: (evt: any, annotation: any, handle: any, interactionType?: string) => void;
     _endCallback: (evt: any) => void;
     _dragCallback: (evt: any) => void;
-    cancel(element: any): any;
+    cancel(element: any): string;
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;
     _activateModify: (element: any) => void;

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

@@ -424,7 +424,7 @@ class VideoRedactionTool extends AnnotationTool {
         data.handles.activeHandleIndex = null;
         triggerAnnotationRenderForViewportIds(viewportUIDsToRender);
         this.editData = null;
-        return annotation.metadata.annotationUID;
+        return annotation.annotationUID;
     }
     _getImageVolumeFromTargetUID(targetUID, renderingEngine) {
         let imageVolume, viewport;

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -40,17 +40,7 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     private _imagePointNearToolOrHandle;
     protected static createAnnotationState(annotation: Annotation, deleting?: boolean): {
         annotationUID: string;
-        data: {
-            [key: string]: unknown;
-            handles?: import("../../types/AnnotationTypes").Handles;
-            cachedStats?: Record<string, unknown>;
-            label?: string;
-            contour?: {
-                polyline?: Types.Point3[];
-                pointsManager?: Types.IPointsManager<Types.Point3>;
-                closed?: boolean;
-            };
-        };
+        data: import("../../types").AnnotationData;
         deleting: boolean;
     };
     static createAnnotationMemo(element: any, annotation: Annotation, options?: {

package/dist/esm/tools/base/BaseTool.d.ts

@@ -34,5 +34,7 @@ declare abstract class BaseTool {
         restoreMemo: () => void;
     };
     doneEditMemo(): void;
+    static startGroupRecording(): void;
+    static endGroupRecording(): void;
 }
 export default BaseTool;

package/dist/esm/tools/base/BaseTool.js

@@ -123,6 +123,12 @@ class BaseTool {
         }
         this.memo = null;
     }
+    static startGroupRecording() {
+        DefaultHistoryMemo.startGroupRecording();
+    }
+    static endGroupRecording() {
+        DefaultHistoryMemo.endGroupRecording();
+    }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;

package/dist/esm/tools/index.d.ts

@@ -1,6 +1,8 @@
 import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
 import PanTool from './PanTool';
 import TrackballRotateTool from './TrackballRotateTool';
+import VolumeCroppingTool from './VolumeCroppingTool';
+import VolumeCroppingControlTool from './VolumeCroppingControlTool';
 import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
@@ -58,4 +60,4 @@ import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

package/dist/esm/tools/index.js

@@ -1,6 +1,8 @@
 import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
 import PanTool from './PanTool';
 import TrackballRotateTool from './TrackballRotateTool';
+import VolumeCroppingTool from './VolumeCroppingTool';
+import VolumeCroppingControlTool from './VolumeCroppingControlTool';
 import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
@@ -58,4 +60,4 @@ import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

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

@@ -140,7 +140,8 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = getEnabledElement(element);
+            const { metadata } = annotation;
+            const { enabledElement } = metadata;
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -176,6 +177,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 const { annotationUID, data, metadata } = annotation;
                 const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
+                const { enabledElement: annotationEnabledElement } = metadata;
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
@@ -219,8 +221,12 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     isMiddleSlice = true;
                 }
                 data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = middleCoordinate;
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                const iteratorVolumeIDs = annotationEnabledElement.viewport?.volumeIds.values();
+                for (const volumeId of iteratorVolumeIDs) {
+                    if (annotation.invalidated &&
+                        annotation.metadata.volumeId === volumeId) {
+                        this._throttledCalculateCachedStats(annotation, annotationEnabledElement);
+                    }
                 }
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
@@ -323,24 +329,32 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
-        const handlesToStart = csUtils.deepClone(points);
+        const projectionAxisIndex = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
         const startWorld = vec3.clone(points[0]);
+        startWorld[projectionAxisIndex] = startCoordinate;
         const endWorld = vec3.clone(points[0]);
-        const indexOfNormal = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
-        startWorld[indexOfNormal] = startCoordinate;
-        endWorld[indexOfNormal] = endCoordinate;
-        handlesToStart.forEach((handlePoint) => {
-            handlePoint[indexOfNormal] = startCoordinate;
-        });
-        const distance = vec3.distance(startWorld, endWorld);
-        const newProjectionPoints = [];
-        if (distance >= 0) {
-            newProjectionPoints.push(handlesToStart.map((p) => Array.from(p)));
+        endWorld[projectionAxisIndex] = endCoordinate;
+        const direction = vec3.create();
+        vec3.subtract(direction, endWorld, startWorld);
+        const distance = vec3.length(direction);
+        if (distance === 0) {
+            const handlesOnStartPlane = points.map((p) => {
+                const newPoint = vec3.clone(p);
+                newPoint[projectionAxisIndex] = startCoordinate;
+                return Array.from(newPoint);
+            });
+            data.cachedStats.projectionPoints = [handlesOnStartPlane];
+            return;
         }
-        for (let dist = spacingInNormal; dist <= distance; dist += spacingInNormal) {
+        vec3.normalize(direction, direction);
+        const handlesToStart = csUtils.deepClone(points);
+        handlesToStart[0][projectionAxisIndex] = startCoordinate;
+        handlesToStart[1][projectionAxisIndex] = startCoordinate;
+        const newProjectionPoints = [];
+        for (let dist = 0; dist <= distance + 1e-6; dist += spacingInNormal) {
             newProjectionPoints.push(handlesToStart.map((point) => {
                 const newPoint = vec3.create();
-                vec3.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
+                vec3.scaleAndAdd(newPoint, point, direction, dist);
                 return Array.from(newPoint);
             }));
         }

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

@@ -68,6 +68,8 @@ export default class LabelmapBaseTool extends BaseTool {
     constructor(toolProps: any, defaultToolProps: any);
     protected _historyRedoHandler(evt: any): void;
     protected get _previewData(): PreviewData;
+    hasPreviewData(): boolean;
+    shouldResolvePreviewRequests(): boolean;
     createMemo(segmentationId: string, segmentationVoxelManager: any): LabelmapMemo.LabelmapMemo;
     protected createEditData(element: any): EditDataReturnType;
     protected getEditData({ viewport, representationData, segmentsLocked, segmentationId, }: {

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

@@ -54,6 +54,13 @@ export default class LabelmapBaseTool extends BaseTool {
     get _previewData() {
         return LabelmapBaseTool.previewData;
     }
+    hasPreviewData() {
+        return !!this._previewData.preview;
+    }
+    shouldResolvePreviewRequests() {
+        return ((this.mode === 'Active' || this.mode === 'Enabled') &&
+            this.hasPreviewData());
+    }
     createMemo(segmentationId, segmentationVoxelManager) {
         const voxelManagerId = segmentationVoxelManager.id;
         if (this.memo &&
@@ -229,6 +236,10 @@ export default class LabelmapBaseTool extends BaseTool {
         const enabledElement = getEnabledElement(element);
         const results = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
         _previewData.isDrag = true;
+        if (results?.modified) {
+            _previewData.preview = results;
+            _previewData.element = element;
+        }
         return results;
     }
     rejectPreview(element = this._previewData.element) {

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

@@ -128,7 +128,8 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = getEnabledElement(element);
+            const { metadata } = annotation;
+            const { enabledElement } = metadata;
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -164,6 +165,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 const { annotationUID, data, metadata } = annotation;
                 const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
+                const { enabledElement: annotationEnabledElement } = metadata;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
@@ -194,8 +196,12 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                     roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                const iteratorVolumeIDs = annotationEnabledElement.viewport?.volumeIds.values();
+                for (const volumeId of iteratorVolumeIDs) {
+                    if (annotation.invalidated &&
+                        annotation.metadata.volumeId === volumeId) {
+                        this._throttledCalculateCachedStats(annotation, annotationEnabledElement);
+                    }
                 }
                 let firstOrLastSlice = false;
                 if (roundedCoord === roundedStartCoord ||

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

@@ -1,11 +1,12 @@
 import { getEnabledElement } from '@cornerstonejs/core';
+import { config as segmentationConfig } from '../../stateManagement/segmentation';
 import { BaseTool } from '../base';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getActiveSegmentation } from '../../stateManagement/segmentation/activeSegmentation';
 import { getSegmentIndexAtWorldPoint } from '../../utilities/segmentation';
 import { state } from '../../store/state';
-import { drawLinkedTextBox as drawLinkedTextBoxSvg } from '../../drawingSvg';
+import { drawTextBox as drawTextBoxSvg } from '../../drawingSvg';
 class SegmentLabelTool extends BaseTool {
     constructor(toolProps = {
         data: {
@@ -26,6 +27,8 @@ class SegmentLabelTool extends BaseTool {
         configuration: {
             hoverTimeout: 100,
             searchRadius: 6,
+            color: null,
+            background: null,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -90,13 +93,15 @@ class SegmentLabelTool extends BaseTool {
             viewport,
         });
         const segment = activeSegmentation.segments[hoveredSegmentIndex];
+        const color = this.configuration.color ??
+            segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, hoveredSegmentIndex);
         const label = segment?.label;
         const canvasCoordinates = viewport.worldToCanvas(worldPoint);
         this._editData = {
             hoveredSegmentIndex,
             hoveredSegmentLabel: label,
             canvasCoordinates,
-            worldPoint,
+            color,
         };
         if (!hoveredSegmentIndex || hoveredSegmentIndex === 0) {
             return;
@@ -111,12 +116,19 @@ class SegmentLabelTool extends BaseTool {
             return;
         }
         const { viewport } = enabledElement;
-        const { hoveredSegmentIndex, hoveredSegmentLabel, canvasCoordinates, worldPoint, } = this._editData;
+        const { hoveredSegmentIndex, hoveredSegmentLabel, canvasCoordinates, color, } = this._editData;
         if (!hoveredSegmentIndex) {
             return;
         }
-        const textBoxPosition = viewport.worldToCanvas(worldPoint);
-        const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, 'segmentSelectLabelAnnotation', 'segmentSelectLabelTextBox', [hoveredSegmentLabel ? hoveredSegmentLabel : '(unnamed segment)'], textBoxPosition, [canvasCoordinates], {}, {});
+        const offset = -15;
+        const textBoxPosition = [
+            canvasCoordinates[0] + offset,
+            canvasCoordinates[1] + offset,
+        ];
+        const boundingBox = drawTextBoxSvg(svgDrawingHelper, 'segmentSelectLabelAnnotation', 'segmentSelectLabelTextBox', [hoveredSegmentLabel ?? '(unnamed segment)'], textBoxPosition, {
+            color: `rgba(${color[0]}, ${color[1]}, ${color[2]}, ${color[3]})`,
+            background: this.configuration.background ?? undefined,
+        });
         const left = canvasCoordinates[0];
         const top = canvasCoordinates[1];
         const { width, height } = boundingBox;

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

@@ -37,6 +37,7 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
         };
     };
     memo?: LabelmapMemo;
+    modified?: boolean;
 };
 export type StrategyFunction = (operationData: InitializedOperationData, ...args: any[]) => unknown;
 export type CompositionInstance = {

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -18,6 +18,7 @@ export default {
     },
     [StrategyCallbacks.Initialize]: (operationData) => {
         const { segmentIndex, previewColor, previewSegmentIndex } = operationData;
+        operationData.modified = false;
         if (previewSegmentIndex == null || segmentIndex == null) {
             return;
         }
@@ -25,6 +26,7 @@ export default {
         viewportIds?.forEach((viewportId) => {
             setSegmentIndexColor(viewportId, operationData.segmentationId, previewSegmentIndex, previewColor);
         });
+        operationData.modified = true;
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
         const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, centerSegmentIndexInfo, } = operationData || {};

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

@@ -1,11 +1,8 @@
-import { vec3 } from 'gl-matrix';
 import type { Types } from '@cornerstonejs/core';
 import BrushStrategy from './BrushStrategy';
-declare function createPointInEllipse(worldInfo: {
-    topLeftWorld: Types.Point3;
-    bottomRightWorld: Types.Point3;
-    center: Types.Point3 | vec3;
-}): (pointLPS: Types.Point3) => boolean;
+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 const CIRCLE_STRATEGY: BrushStrategy;
 declare const CIRCLE_THRESHOLD_STRATEGY: BrushStrategy;
 declare const fillInsideCircle: (enabledElement: any, operationData: any) => unknown;

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

@@ -1,50 +1,67 @@
 import { vec3 } from 'gl-matrix';
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { getCanvasEllipseCorners, precalculatePointInEllipse, } from '../../../utilities/math/ellipse';
 import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 import { pointInSphere } from '../../../utilities/math/sphere';
 const { transformWorldToIndex, isEqual } = csUtils;
+export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
+    const [bottom, top, left, right] = canvasCoordinates;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    const bottomLeft = [left[0], bottom[1]];
+    const topRight = [right[0], top[1]];
+    return [topLeft, bottomRight, bottomLeft, topRight];
+}
 const initializeCircle = {
     [StrategyCallbacks.Initialize]: (operationData) => {
         const { points, viewport, segmentationImageData, } = operationData;
         if (!points) {
             return;
         }
-        const center = vec3.fromValues(0, 0, 0);
-        points.forEach((point) => {
-            vec3.add(center, center, point);
-        });
-        vec3.scale(center, center, 1 / points.length);
+        const center = vec3.create();
+        if (points.length >= 2) {
+            vec3.add(center, points[0], points[1]);
+            vec3.scale(center, center, 0.5);
+        }
+        else {
+            vec3.copy(center, points[0]);
+        }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const [topLeftCanvas, bottomRightCanvas] = getCanvasEllipseCorners(canvasCoordinates);
-        const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-        const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+        const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
+        const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
         const circleCornersIJK = points.map((world) => {
             return transformWorldToIndex(segmentationImageData, world);
         });
         const boundsIJK = getBoundingBoxAroundShapeIJK(circleCornersIJK, segmentationImageData.getDimensions());
-        operationData.isInObject = createPointInEllipse({
-            topLeftWorld,
-            bottomRightWorld,
-            center,
-        });
+        operationData.isInObject = createPointInEllipse(cornersInWorld);
         operationData.isInObjectBoundsIJK = boundsIJK;
     },
 };
-function createPointInEllipse(worldInfo) {
-    const { topLeftWorld, bottomRightWorld, center } = worldInfo;
-    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 radius = Math.max(xRadius, yRadius, zRadius);
-    if (isEqual(xRadius, radius) &&
-        isEqual(yRadius, radius) &&
-        isEqual(zRadius, radius)) {
+function createPointInEllipse(cornersInWorld = []) {
+    if (!cornersInWorld || cornersInWorld.length !== 4) {
+        throw new Error('createPointInEllipse: cornersInWorld must have 4 points');
+    }
+    const [topLeft, bottomRight, bottomLeft, topRight] = cornersInWorld;
+    const center = vec3.create();
+    vec3.add(center, topLeft, bottomRight);
+    vec3.scale(center, center, 0.5);
+    const majorAxisVec = vec3.create();
+    vec3.subtract(majorAxisVec, topRight, topLeft);
+    const xRadius = vec3.length(majorAxisVec) / 2;
+    vec3.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = vec3.create();
+    vec3.subtract(minorAxisVec, bottomLeft, topLeft);
+    const yRadius = vec3.length(minorAxisVec) / 2;
+    vec3.normalize(minorAxisVec, minorAxisVec);
+    const normal = vec3.create();
+    vec3.cross(normal, majorAxisVec, minorAxisVec);
+    vec3.normalize(normal, normal);
+    if (isEqual(xRadius, yRadius)) {
+        const radius = xRadius;
         const sphereObj = {
             center,
             radius,
@@ -52,14 +69,20 @@ function createPointInEllipse(worldInfo) {
         };
         return (pointLPS) => pointInSphere(sphereObj, pointLPS);
     }
-    const ellipseObj = {
-        center: center,
-        xRadius,
-        yRadius,
-        zRadius,
+    return (pointLPS) => {
+        const pointVec = vec3.create();
+        vec3.subtract(pointVec, pointLPS, center);
+        const distToPlane = vec3.dot(pointVec, normal);
+        const proj = vec3.create();
+        vec3.scaleAndAdd(proj, pointVec, normal, -distToPlane);
+        const fromTopLeft = vec3.create();
+        const centerToTopLeft = vec3.create();
+        vec3.subtract(centerToTopLeft, center, topLeft);
+        vec3.subtract(fromTopLeft, proj, centerToTopLeft);
+        const x = vec3.dot(fromTopLeft, majorAxisVec);
+        const y = vec3.dot(fromTopLeft, minorAxisVec);
+        return (x * x) / (xRadius * xRadius) + (y * y) / (yRadius * yRadius) <= 1;
     };
-    const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
-    return precalculated;
 }
 const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
 const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);

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

@@ -1,16 +1,13 @@
 import { vec3 } from 'gl-matrix';
 import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
-import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from '../../../utilities/boundingBox';
-import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { getStrategyData } from './utils/getStrategyData';
-import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
+import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 const { transformWorldToIndex } = csUtils;
 const initializeRectangle = {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
+        const { points, viewport, segmentationImageData, } = operationData;
         if (!points) {
             return;
         }
@@ -36,8 +33,18 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         });
     });
     const boundsIJK = getBoundingBoxAroundShapeIJK(rectangleCornersIJK, segmentationImageData.getDimensions());
-    const isStackViewport = viewport instanceof StackViewport;
-    const isAligned = isStackViewport || isAxisAlignedRectangle(rectangleCornersIJK);
+    const [p0, p1, p2, p3] = points;
+    const axisU = vec3.create();
+    const axisV = vec3.create();
+    vec3.subtract(axisU, p1, p0);
+    vec3.subtract(axisV, p3, p0);
+    const uLen = vec3.length(axisU);
+    const vLen = vec3.length(axisV);
+    vec3.normalize(axisU, axisU);
+    vec3.normalize(axisV, axisV);
+    const normal = vec3.create();
+    vec3.cross(normal, axisU, axisV);
+    vec3.normalize(normal, normal);
     const direction = segmentationImageData.getDirection();
     const spacing = segmentationImageData.getSpacing();
     const { viewPlaneNormal } = viewport.getCamera();
@@ -45,23 +52,18 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         direction,
         spacing,
     }, viewPlaneNormal);
-    const pointsBoundsLPS = getBoundingBoxAroundShapeWorld(points);
-    let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
-    xMin -= EPS;
-    xMax += EPS;
-    yMin -= EPS;
-    yMax += EPS;
-    zMin -= EPS;
-    zMax += EPS;
-    const pointInShapeFn = isAligned
-        ? () => true
-        : (pointLPS) => {
-            const [x, y, z] = pointLPS;
-            const xInside = x >= xMin && x <= xMax;
-            const yInside = y >= yMin && y <= yMax;
-            const zInside = z >= zMin && z <= zMax;
-            return xInside && yInside && zInside;
-        };
+    const pointInShapeFn = (pointLPS) => {
+        const v = vec3.create();
+        vec3.subtract(v, pointLPS, p0);
+        const u = vec3.dot(v, axisU);
+        const vproj = vec3.dot(v, axisV);
+        const d = Math.abs(vec3.dot(v, normal));
+        return (u >= -EPS &&
+            u <= uLen + EPS &&
+            vproj >= -EPS &&
+            vproj <= vLen + EPS &&
+            d <= EPS);
+    };
     return { boundsIJK, pointInShapeFn };
 }
 const RECTANGLE_STRATEGY = new BrushStrategy('Rectangle', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);

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

@@ -3,7 +3,7 @@ import { vec3 } from 'gl-matrix';
 import BrushStrategy from './BrushStrategy';
 import compositions from './compositions';
 import StrategyCallbacks from '../../../enums/StrategyCallbacks';
-import { createEllipseInPoint } from './fillCircle';
+import { createEllipseInPoint, getEllipseCornersFromCanvasCoordinates, } from './fillCircle';
 const { transformWorldToIndex } = csUtils;
 import { getSphereBoundsInfoFromViewport } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
@@ -12,20 +12,22 @@ const sphereComposition = {
         if (!points) {
             return;
         }
-        const center = vec3.fromValues(0, 0, 0);
-        points.forEach((point) => {
-            vec3.add(center, center, point);
-        });
-        vec3.scale(center, center, 1 / points.length);
+        const center = vec3.create();
+        if (points.length >= 2) {
+            vec3.add(center, points[0], points[1]);
+            vec3.scale(center, center, 0.5);
+        }
+        else {
+            vec3.copy(center, points[0]);
+        }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
+        const { boundsIJK: newBoundsIJK } = 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({
-            topLeftWorld,
-            bottomRightWorld,
-            center,
-        });
+        operationData.isInObject = createEllipseInPoint(cornersInWorld);
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.ensureSegmentationVolumeFor3DManipulation);