@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,15 +1,20 @@
-import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
+import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { vec3, vec2 } from 'gl-matrix';
 import { BaseTool } from '../base';
 import { fillInsideSphere, thresholdInsideSphere, } from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import { thresholdInsideCircle, fillInsideCircle, } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
-import { Events, ToolModes } from '../../enums';
+import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } from '../../enums';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -23,119 +28,153 @@ class BrushTool extends BaseTool {
                 THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
             },
             strategySpecificConfiguration: {
-                THRESHOLD_INSIDE_CIRCLE: {
+                THRESHOLD: {
                     threshold: [-150, -70],
                 },
             },
             defaultStrategy: 'FILL_INSIDE_CIRCLE',
             activeStrategy: 'FILL_INSIDE_CIRCLE',
+            thresholdVolumeId: null,
             brushSize: 25,
+            preview: {
+                enabled: false,
+                previewColors: {},
+                previewTimeMs: 250,
+                previewMoveDistance: 8,
+                dragMoveDistance: 4,
+                dragTimeMs: 500,
+            },
+            actions: {
+                [StrategyCallbacks.AcceptPreview]: {
+                    method: StrategyCallbacks.AcceptPreview,
+                    bindings: [
+                        {
+                            key: 'Enter',
+                        },
+                    ],
+                },
+                [StrategyCallbacks.RejectPreview]: {
+                    method: StrategyCallbacks.RejectPreview,
+                    bindings: [
+                        {
+                            key: 'Escape',
+                        },
+                    ],
+                },
+            },
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.onSetToolPassive = () => {
+        this._previewData = {
+            preview: null,
+            element: null,
+            timerStart: 0,
+            timer: null,
+            startPoint: [NaN, NaN],
+            isDrag: false,
+        };
+        this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
         this.onSetToolEnabled = () => {
             this.disableCursor();
         };
-        this.onSetToolDisabled = () => {
+        this.onSetToolDisabled = (evt) => {
             this.disableCursor();
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
-            if (viewport instanceof StackViewport) {
-                throw new Error('Not implemented yet');
-            }
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-            if (!activeSegmentationRepresentation) {
-                throw new Error('No active segmentation detected, create one before using the brush tool');
-            }
-            const { segmentationId, type } = activeSegmentationRepresentation;
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
-            const { representationData } = segmentationState.getSegmentation(segmentationId);
-            const { volumeId } = representationData[type];
-            const segmentation = cache.getVolume(volumeId);
-            const actors = viewport.getActors();
-            const firstVolumeActorUID = actors[0].uid;
-            const imageVolume = cache.getVolume(firstVolumeActorUID);
-            const viewportIdsToRender = [viewport.id];
-            this._editData = {
-                segmentation,
-                imageVolume,
-                segmentsLocked,
-            };
+            this._editData = this.createEditData(element);
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportUIDs(renderingEngine, viewportIdsToRender);
+            this._previewData.isDrag = false;
+            this._previewData.timerStart = Date.now();
+            const hoverData = this._hoverData || this.createHoverData(element);
+            triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
+            const operationData = this.getOperationData(element);
+            this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionStart);
             return true;
         };
         this.mouseMoveCallback = (evt) => {
             if (this.mode === ToolModes.Active) {
                 this.updateCursor(evt);
+                if (!this.configuration.preview.enabled) {
+                    return;
+                }
+                const { previewTimeMs, previewMoveDistance, dragMoveDistance } = this.configuration.preview;
+                const { currentPoints, element } = evt.detail;
+                const { canvas } = currentPoints;
+                const { preview, startPoint, timer, timerStart, isDrag } = this._previewData;
+                const delta = vec2.distance(canvas, startPoint);
+                const time = Date.now() - timerStart;
+                if (delta > previewMoveDistance ||
+                    (time > previewTimeMs && delta > dragMoveDistance)) {
+                    if (timer) {
+                        window.clearTimeout(timer);
+                        this._previewData.timer = null;
+                    }
+                    if (preview && !isDrag) {
+                        this.rejectPreview(element);
+                    }
+                }
+                if (!this._previewData.timer) {
+                    const timer = window.setTimeout(this.previewCallback, 250);
+                    Object.assign(this._previewData, {
+                        timerStart: Date.now(),
+                        timer,
+                        startPoint: canvas,
+                        element,
+                    });
+                }
+            }
+        };
+        this.previewCallback = () => {
+            this._previewData.timer = null;
+            if (this._previewData.preview) {
+                return;
             }
+            this._previewData.preview = this.applyActiveStrategyCallback(getEnabledElement(this._previewData.element), this.getOperationData(this._previewData.element), StrategyCallbacks.Preview);
         };
         this._dragCallback = (evt) => {
             const eventData = evt.detail;
-            const { element } = eventData;
+            const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
-            const { imageVolume, segmentation, segmentsLocked } = this._editData;
             this.updateCursor(evt);
-            const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, viewportIdsToRender, } = this._hoverData;
-            const { data } = brushCursor;
-            const { viewPlaneNormal, viewUp } = brushCursor.metadata;
-            triggerAnnotationRenderForViewportUIDs(renderingEngine, viewportIdsToRender);
-            const operationData = {
-                points: data.handles.points,
-                volume: segmentation,
-                imageVolume,
-                segmentIndex,
-                segmentsLocked,
-                viewPlaneNormal,
-                toolGroupId: this.toolGroupId,
-                segmentationId,
-                segmentationRepresentationUID,
-                viewUp,
-                strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
-            };
-            this.applyActiveStrategy(enabledElement, operationData);
+            const { viewportIdsToRender } = this._hoverData;
+            triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
+            const delta = vec2.distance(currentPoints.canvas, this._previewData.startPoint);
+            const { dragTimeMs, dragMoveDistance } = this.configuration.preview;
+            if (!this._previewData.isDrag &&
+                this._previewData.preview &&
+                Date.now() - this._previewData.timerStart < dragTimeMs &&
+                delta < dragMoveDistance) {
+                return;
+            }
+            this._previewData.preview = this.applyActiveStrategy(enabledElement, this.getOperationData(element));
+            this._previewData.element = element;
+            this._previewData.timerStart = Date.now() + dragTimeMs;
+            this._previewData.isDrag = true;
+            this._previewData.startPoint = currentPoints.canvas;
         };
         this._endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
-            const { imageVolume, segmentation, segmentsLocked } = this._editData;
-            const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, } = this._hoverData;
-            const { data } = brushCursor;
-            const { viewPlaneNormal, viewUp } = brushCursor.metadata;
+            const enabledElement = getEnabledElement(element);
+            const operationData = this.getOperationData(element);
+            if (!this._previewData.preview && !this._previewData.isDrag) {
+                this.applyActiveStrategy(enabledElement, operationData);
+            }
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { viewport } = enabledElement;
-            this._editData = null;
             this.updateCursor(evt);
-            if (viewport instanceof StackViewport) {
-                throw new Error('Not implemented yet');
+            this._editData = null;
+            this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionEnd);
+            if (!this._previewData.isDrag) {
+                this.acceptPreview(element);
             }
-            const operationData = {
-                points: data.handles.points,
-                volume: segmentation,
-                imageVolume,
-                segmentIndex,
-                segmentsLocked,
-                viewPlaneNormal,
-                toolGroupId: this.toolGroupId,
-                segmentationId,
-                segmentationRepresentationUID,
-                viewUp,
-                strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
-            };
-            this.applyActiveStrategy(enabledElement, operationData);
         };
         this._activateDraw = (element) => {
             element.addEventListener(Events.MOUSE_UP, this._endCallback);
@@ -150,26 +189,104 @@ class BrushTool extends BaseTool {
     }
     disableCursor() {
         this._hoverData = undefined;
+        this.rejectPreview();
     }
-    updateCursor(evt) {
-        const eventData = evt.detail;
-        const { element } = eventData;
-        const { currentPoints } = eventData;
-        const centerCanvas = currentPoints.canvas;
+    createEditData(element) {
         const enabledElement = getEnabledElement(element);
-        const { renderingEngine, viewport } = enabledElement;
+        const { viewport } = enabledElement;
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+            return null;
+        }
+        const { segmentationId } = activeSegmentation;
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
+        if (viewport instanceof BaseVolumeViewport) {
+            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
+            const actors = viewport.getActors();
+            const isStackViewport = viewport instanceof StackViewport;
+            if (isStackViewport) {
+                const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                    detail: {
+                        type: 'Segmentation',
+                        message: 'Cannot perform brush operation on the selected viewport',
+                    },
+                    cancelable: true,
+                });
+                eventTarget.dispatchEvent(event);
+                return null;
+            }
+            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
+            const segmentationVolume = cache.getVolume(volumeId);
+            const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
+            return {
+                volumeId,
+                referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
+                segmentsLocked,
+            };
+        }
+        else {
+            const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+            if (!segmentationImageId) {
+                return;
+            }
+            if (this.configuration.activeStrategy.includes('SPHERE')) {
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
+                if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                    };
+                }
+                const tempVolumeId = 'tempVolumeId';
+                const { dimensions, direction, origin, spacing, numberOfComponents, imageIds: sortedLabelmapImageIds, } = csUtils.generateVolumePropsFromImageIds(labelmapImageIds, tempVolumeId);
+                const newVoxelManager = csUtils.VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds: sortedLabelmapImageIds,
+                    numberOfComponents,
+                });
+                const newImageData = vtkImageData.newInstance();
+                newImageData.setDimensions(dimensions);
+                newImageData.setSpacing(spacing);
+                newImageData.setDirection(direction);
+                newImageData.setOrigin(origin);
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                    override: {
+                        voxelManager: newVoxelManager,
+                        imageData: newImageData,
+                    },
+                };
+            }
+            else {
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
+            }
+        }
+    }
+    createHoverData(element, centerCanvas) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
         const camera = viewport.getCamera();
         const { viewPlaneNormal, viewUp } = camera;
-        const toolGroupId = this.toolGroupId;
-        const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-        if (!activeSegmentationRepresentation) {
-            console.warn('No active segmentation detected, create one before using the brush tool');
-            return;
-        }
-        const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
-        const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-        const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
         const viewportIdsToRender = [viewport.id];
+        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
         const brushCursor = {
             metadata: {
                 viewPlaneNormal: [...viewPlaneNormal],
@@ -181,17 +298,67 @@ class BrushTool extends BaseTool {
             },
             data: {},
         };
-        this._hoverData = {
+        return {
             brushCursor,
             centerCanvas,
             segmentIndex,
+            viewport,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
             viewportIdsToRender,
         };
+    }
+    getActiveSegmentationData(viewport) {
+        const viewportId = viewport.id;
+        const activeRepresentation = getActiveSegmentation(viewportId);
+        if (!activeRepresentation) {
+            console.warn('No active segmentation detected, create one before using the brush tool');
+            return;
+        }
+        const { segmentationId } = activeRepresentation;
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        if (!segmentIndex) {
+            return;
+        }
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
+        return {
+            segmentIndex,
+            segmentationId,
+            segmentColor,
+        };
+    }
+    updateCursor(evt) {
+        const eventData = evt.detail;
+        const { element } = eventData;
+        const { currentPoints } = eventData;
+        const centerCanvas = currentPoints.canvas;
+        this._hoverData = this.createHoverData(element, centerCanvas);
         this._calculateCursor(element, centerCanvas);
-        triggerAnnotationRenderForViewportUIDs(renderingEngine, viewportIdsToRender);
+        if (!this._hoverData) {
+            return;
+        }
+        triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
+    }
+    getOperationData(element) {
+        const editData = this._editData || this.createEditData(element);
+        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
+        const { data, metadata = {} } = brushCursor || {};
+        const { viewPlaneNormal, viewUp } = metadata;
+        const operationData = {
+            ...editData,
+            points: data?.handles?.points,
+            segmentIndex,
+            previewColors: this.configuration.preview.enabled
+                ? this.configuration.preview.previewColors
+                : null,
+            viewPlaneNormal,
+            toolGroupId: this.toolGroupId,
+            segmentationId,
+            viewUp,
+            strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
+            preview: this._previewData?.preview,
+        };
+        return operationData;
     }
     _calculateCursor(element, centerCanvas) {
         const enabledElement = getEnabledElement(element);
@@ -217,6 +384,9 @@ class BrushTool extends BaseTool {
             leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
             rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
         }
+        if (!this._hoverData) {
+            return;
+        }
         const { brushCursor } = this._hoverData;
         const { data } = brushCursor;
         if (data.handles === undefined) {
@@ -228,13 +398,43 @@ class BrushTool extends BaseTool {
             leftCursorInWorld,
             rightCursorInWorld,
         ];
+        const activeStrategy = this.configuration.activeStrategy;
+        const strategy = this.configuration.strategies[activeStrategy];
+        if (typeof strategy.computeInnerCircleRadius === 'function') {
+            strategy.computeInnerCircleRadius({
+                configuration: this.configuration,
+                viewport,
+            });
+        }
         data.invalidated = false;
     }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+    }
     invalidateBrushCursor() {
-        if (this._hoverData !== undefined) {
-            const { data } = this._hoverData.brushCursor;
-            data.invalidated = true;
+        if (this._hoverData === undefined) {
+            return;
         }
+        const { data } = this._hoverData.brushCursor;
+        const { viewport } = this._hoverData;
+        data.invalidated = true;
+        const { segmentColor } = this.getActiveSegmentationData(viewport) || {};
+        this._hoverData.brushCursor.metadata.segmentColor = segmentColor;
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
         if (!this._hoverData) {
@@ -252,6 +452,9 @@ class BrushTool extends BaseTool {
             this._calculateCursor(element, centerCanvas);
         }
         const toolMetadata = brushCursor.metadata;
+        if (!toolMetadata) {
+            return;
+        }
         const annotationUID = toolMetadata.brushCursorUID;
         const data = brushCursor.data;
         const { points } = data.handles;
@@ -263,7 +466,7 @@ class BrushTool extends BaseTool {
             Math.floor((bottom[1] + top[1]) / 2),
         ];
         const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
-        const color = `rgb(${toolMetadata.segmentColor.slice(0, 3)})`;
+        const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
         if (!viewport.getRenderingEngine()) {
             console.warn('Rendering Engine has been destroyed');
             return;
@@ -272,8 +475,18 @@ class BrushTool extends BaseTool {
         drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
             color,
         });
+        const activeStrategy = this.configuration.activeStrategy;
+        const { dynamicRadiusInCanvas } = this.configuration
+            .strategySpecificConfiguration[activeStrategy] || {
+            dynamicRadiusInCanvas: 0,
+        };
+        if (dynamicRadiusInCanvas) {
+            const circleUID1 = '1';
+            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
+                color,
+            });
+        }
     }
 }
 BrushTool.toolName = 'Brush';
 export default BrushTool;
-//# sourceMappingURL=BrushTool.js.map

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

@@ -0,0 +1,68 @@
+import type { Types } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+import type { CircleROIStartEndThresholdAnnotation, ROICachedStats } from '../../types/ToolSpecificAnnotationTypes';
+import CircleROITool from '../annotation/CircleROITool';
+declare class CircleROIStartEndThresholdTool extends CircleROITool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        annotation: Annotation;
+        viewportIdsToRender: Array<string>;
+        handleIndex?: number;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => {
+        highlighted: boolean;
+        invalidated: boolean;
+        metadata: {
+            toolName: string;
+            viewPlaneNormal: Types.Point3;
+            viewUp: Types.Point3;
+            FrameOfReferenceUID: string;
+            referencedImageId: any;
+            volumeId: any;
+            spacingInNormal: number;
+            enabledElement: Types.IEnabledElement;
+        };
+        data: {
+            label: string;
+            startCoordinate: number;
+            endCoordinate: number;
+            handles: {
+                textBox: {
+                    hasMoved: boolean;
+                    worldPosition: Types.Point3;
+                    worldBoundingBox: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
+                };
+                points: [Types.Point3, Types.Point3];
+                activeHandleIndex: any;
+            };
+            cachedStats: {
+                pointsInVolume: any[];
+                projectionPoints: any[];
+                statistics: ROICachedStats;
+            };
+            labelmapUID: any;
+        };
+    };
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    _computeProjectionPoints(annotation: CircleROIStartEndThresholdAnnotation, imageVolume: Types.IImageVolume): void;
+    _computePointsInsideVolume(annotation: any, imageVolume: any, targetId: any, enabledElement: any): void;
+    _calculateCachedStatsTool(annotation: any, enabledElement: any): any;
+    _getStartCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getEndCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal: Types.Point3): number;
+    _getCoordinateForViewplaneNormal(pos: vec3 | number, viewPlaneNormal: Types.Point3): number | undefined;
+}
+export default CircleROIStartEndThresholdTool;