@cornerstonejs/tools 5.6.14 → 5.7.1

package/dist/esm/tools/CrosshairsTool.js

@@ -14,6 +14,7 @@ import getViewportICamera from '../utilities/getViewportICamera.js';
 import { resetElementCursor, hideElementCursor, } from '../cursors/elementCursor.js';
 import liangBarksyClip from '../utilities/math/vec2/liangBarksyClip.js';
 import { getSlabThicknessOrDefault, jumpToFocalPoint, } from '../utilities/genericViewportToolHelpers.js';
+import { isMobile } from '../utilities/touch/index.js';
 import * as lineSegment from '../utilities/math/line/index.js';
 import { isAnnotationLocked } from '../stateManagement/annotation/annotationLocking.js';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds.js';
@@ -48,7 +49,7 @@ const OPERATION = {
 };
 class CrosshairsTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
-        supportedInteractionTypes: ['Mouse'],
+        supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             shadow: true,
             viewportIndicators: false,
@@ -77,7 +78,7 @@ class CrosshairsTool extends AnnotationTool {
                 size: 2,
             },
             mobile: {
-                enabled: false,
+                enabled: isMobile(),
                 opacity: 0.8,
                 handleRadius: 9,
                 referenceLinesCenterGapRatio: 0.05,
@@ -231,7 +232,7 @@ class CrosshairsTool extends AnnotationTool {
             data.handles.activeOperation = OPERATION.DRAG;
             evt.preventDefault();
             hideElementCursor(element);
-            this._activateModify(element);
+            this._activateModify(element, evt);
             return filteredAnnotations[0];
         };
         this.cancel = () => {
@@ -241,12 +242,12 @@ class CrosshairsTool extends AnnotationTool {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             annotation.highlighted = true;
-            this._activateModify(element);
+            this._activateModify(element, evt);
             hideElementCursor(element);
             evt.preventDefault();
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
-            if (this._pointNearTool(element, annotation, canvasCoords, 6)) {
+            if (this._pointNearTool(element, annotation, canvasCoords, proximity)) {
                 return true;
             }
             return false;
@@ -255,7 +256,7 @@ class CrosshairsTool extends AnnotationTool {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             annotation.highlighted = true;
-            this._activateModify(element);
+            this._activateModify(element, evt);
             hideElementCursor(element);
             evt.preventDefault();
         };
@@ -959,13 +960,13 @@ class CrosshairsTool extends AnnotationTool {
             state.isInteractingWithTool = false;
             return true;
         };
-        this._activateModify = (element) => {
+        this._activateModify = (element, evt) => {
             this._syncVolumeListenersWithToolGroup();
             this._recomputeToolCenterFromAbsoluteCameras({
                 emitEvent: false,
                 updateViewportCameras: false,
             });
-            state.isInteractingWithTool = !this.configuration.mobile?.enabled;
+            state.isInteractingWithTool = !(this._isTouchInteraction(evt) && this.configuration.mobile?.enabled);
             element.addEventListener(Events.MOUSE_UP, this._endCallback);
             element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
             element.addEventListener(Events.MOUSE_CLICK, this._endCallback);

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

@@ -9,12 +9,14 @@ declare class MagnifyTool extends BaseTool {
         enabledElement: Types.IEnabledElement;
         renderingEngine: Types.IRenderingEngine;
         currentPoints: IPoints;
+        isTouch: boolean;
     } | null;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     private _hasBeenRemoved;
     _getReferencedImageId(viewport: Types.IViewport): string | undefined;
     preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
     preTouchStartCallback: (evt: EventTypes.InteractionEventType) => void;
+    private _positionMagnifyElement;
     _createMagnificationViewport: () => void;
     _cancelCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;

package/dist/esm/tools/MagnifyTool.js

@@ -15,6 +15,7 @@ class MagnifyTool extends BaseTool {
             magnifySize: 10,
             magnifyWidth: 250,
             magnifyHeight: 250,
+            touchOffset: 40,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -33,12 +34,14 @@ class MagnifyTool extends BaseTool {
                 throw new Error('MagnifyTool: No referenced image id found, reconstructed planes not supported yet');
             }
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            const isTouch = evt.type === Events.TOUCH_START;
             this.editData = {
                 referencedImageId,
                 viewportIdsToRender,
                 enabledElement,
                 renderingEngine,
                 currentPoints,
+                isTouch,
             };
             this._createMagnificationViewport();
             this._activateDraw(element);
@@ -50,6 +53,20 @@ class MagnifyTool extends BaseTool {
         this.preTouchStartCallback = (evt) => {
             this.preMouseDownCallback(evt);
         };
+        this._positionMagnifyElement = (magnifyElement, canvasPos, element) => {
+            const { magnifyWidth, magnifyHeight, touchOffset } = this.configuration;
+            let left = canvasPos[0] - magnifyWidth / 2;
+            let top = canvasPos[1] - magnifyHeight / 2;
+            if (this.editData?.isTouch) {
+                top = canvasPos[1] - magnifyHeight - (touchOffset ?? 0);
+                const maxLeft = Math.max(element.clientWidth - magnifyWidth, 0);
+                const maxTop = Math.max(element.clientHeight - magnifyHeight, 0);
+                left = Math.min(Math.max(left, 0), maxLeft);
+                top = Math.min(Math.max(top, 0), maxTop);
+            }
+            magnifyElement.style.top = `${top}px`;
+            magnifyElement.style.left = `${left}px`;
+        };
         this._createMagnificationViewport = () => {
             const { enabledElement, referencedImageId, viewportIdsToRender, renderingEngine, currentPoints, } = this.editData;
             const { viewport } = enabledElement;
@@ -81,8 +98,7 @@ class MagnifyTool extends BaseTool {
                 };
                 renderingEngine.enableElement(viewportInput);
             }
-            magnifyToolElement.style.top = `${canvasPos[1] - this.configuration.magnifyHeight / 2}px`;
-            magnifyToolElement.style.left = `${canvasPos[0] - this.configuration.magnifyWidth / 2}px`;
+            this._positionMagnifyElement(magnifyToolElement, canvasPos, element);
             const magnifyViewport = renderingEngine.getViewport(MAGNIFY_VIEWPORT_ID);
             magnifyViewport.setStack([referencedImageId]).then(() => {
                 if (this._hasBeenRemoved) {
@@ -146,8 +162,7 @@ class MagnifyTool extends BaseTool {
             if (!magnifyElement) {
                 return;
             }
-            magnifyElement.style.top = `${canvasPos[1] - this.configuration.magnifyHeight / 2}px`;
-            magnifyElement.style.left = `${canvasPos[0] - this.configuration.magnifyWidth / 2}px`;
+            this._positionMagnifyElement(magnifyElement, canvasPos, element);
             const { focalPoint, position } = magnifyViewport.getCamera();
             const updatedPosition = [
                 position[0] + deltaPointsWorld[0],

package/dist/esm/tools/TrackballRotateTool.js

@@ -37,13 +37,20 @@ class TrackballRotateTool extends BaseTool {
                 this._hasResolutionChanged = true;
                 if (this.cleanUp !== null) {
                     document.removeEventListener('mouseup', this.cleanUp);
+                    document.removeEventListener('touchend', this.cleanUp);
+                    document.removeEventListener('touchcancel', this.cleanUp);
                 }
                 this.cleanUp = () => {
+                    document.removeEventListener('mouseup', this.cleanUp);
+                    document.removeEventListener('touchend', this.cleanUp);
+                    document.removeEventListener('touchcancel', this.cleanUp);
                     mapper.setSampleDistance(originalSampleDistance);
                     viewport.render();
                     this._hasResolutionChanged = false;
                 };
                 document.addEventListener('mouseup', this.cleanUp, { once: true });
+                document.addEventListener('touchend', this.cleanUp, { once: true });
+                document.addEventListener('touchcancel', this.cleanUp, { once: true });
             }
             return true;
         };

package/dist/esm/tools/VolumeCroppingTool.js

@@ -17,6 +17,7 @@ import { isDragOwnedBy } from '../utilities/interactionDragCoordinator.js';
 import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation.js';
 class VolumeCroppingTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             showCornerSpheres: true,
             showHandles: true,
@@ -125,8 +126,13 @@ class VolumeCroppingTool extends BaseTool {
                 this._hasResolutionChanged = true;
                 if (this.cleanUp !== null) {
                     document.removeEventListener('mouseup', this.cleanUp);
+                    document.removeEventListener('touchend', this.cleanUp);
+                    document.removeEventListener('touchcancel', this.cleanUp);
                 }
                 this.cleanUp = () => {
+                    document.removeEventListener('mouseup', this.cleanUp);
+                    document.removeEventListener('touchend', this.cleanUp);
+                    document.removeEventListener('touchcancel', this.cleanUp);
                     mapper.setSampleDistance(originalSampleDistance);
                     evt.target.style.cursor = '';
                     if (this.draggingSphereIndex !== null) {
@@ -148,6 +154,8 @@ class VolumeCroppingTool extends BaseTool {
                     this._hasResolutionChanged = false;
                 };
                 document.addEventListener('mouseup', this.cleanUp, { once: true });
+                document.addEventListener('touchend', this.cleanUp, { once: true });
+                document.addEventListener('touchcancel', this.cleanUp, { once: true });
             }
             return true;
         };

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

@@ -1,10 +1,14 @@
 import { BaseTool } from './base/index.js';
-import type { PublicToolProps, ToolProps } from '../types/index.js';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types/index.js';
 import type { MouseWheelEventType } from '../types/EventTypes.js';
 declare class VolumeRotateTool extends BaseTool {
     static toolName: any;
     _configuration: unknown;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     mouseWheelCallback(evt: MouseWheelEventType): void;
+    mouseDragCallback(evt: EventTypes.InteractionEventType): void;
+    touchDragCallback(evt: EventTypes.InteractionEventType): void;
+    _dragCallback(evt: EventTypes.InteractionEventType): void;
+    _rotate(element: HTMLDivElement, angle: number): void;
 }
 export default VolumeRotateTool;

package/dist/esm/tools/VolumeRotateTool.js

@@ -15,21 +15,42 @@ class VolumeRotateTool extends BaseTool {
         configuration: {
             direction: DIRECTIONS.Z,
             rotateIncrementDegrees: 30,
+            rotateDragDegreesPerPixel: 0.5,
         },
     }) {
         super(toolProps, defaultToolProps);
     }
     mouseWheelCallback(evt) {
         const { element, wheel } = evt.detail;
+        const { rotateIncrementDegrees } = this.configuration;
+        const { direction: deltaY } = wheel;
+        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
+        this._rotate(element, angle);
+    }
+    mouseDragCallback(evt) {
+        this._dragCallback(evt);
+    }
+    touchDragCallback(evt) {
+        this._dragCallback(evt);
+    }
+    _dragCallback(evt) {
+        const { element, deltaPoints } = evt.detail;
+        const { rotateDragDegreesPerPixel } = this.configuration;
+        const deltaX = deltaPoints.canvas[0];
+        if (!deltaX) {
+            return;
+        }
+        const angle = (deltaX * rotateDragDegreesPerPixel * Math.PI) / 180;
+        this._rotate(element, angle);
+    }
+    _rotate(element, angle) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const { direction, rotateIncrementDegrees } = this.configuration;
+        const { direction } = this.configuration;
         const camera = getViewportICamera(viewport);
         const { viewUp, position, focalPoint } = camera;
-        const { direction: deltaY } = wheel;
         const [cx, cy, cz] = focalPoint;
         const [ax, ay, az] = direction;
-        const angle = (deltaY * (rotateIncrementDegrees * Math.PI)) / 180;
         const newPosition = [0, 0, 0];
         const newFocalPoint = [0, 0, 0];
         const newViewUp = [0, 0, 0];

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

@@ -30,7 +30,7 @@ declare class ArrowAnnotateTool extends AnnotationTool {
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     touchTapCallback: (evt: EventTypes.TouchTapEventType) => void;
-    doubleClickCallback: (evt: EventTypes.TouchTapEventType) => void;
+    doubleClickCallback: (evt: EventTypes.TouchTapEventType, proximity?: number) => void;
     _doneChangingTextCallback(element: any, annotation: any, updatedLabel: any): void;
     cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;

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

@@ -181,10 +181,10 @@ class ArrowAnnotateTool extends AnnotationTool {
         };
         this.touchTapCallback = (evt) => {
             if (evt.detail.taps == 2) {
-                this.doubleClickCallback(evt);
+                this.doubleClickCallback(evt, _a.TOUCH_PROXIMITY);
             }
         };
-        this.doubleClickCallback = (evt) => {
+        this.doubleClickCallback = (evt, proximity = _a.MOUSE_PROXIMITY) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             let annotations = getAnnotations(this.getToolName(), element);
@@ -192,7 +192,7 @@ class ArrowAnnotateTool extends AnnotationTool {
             if (!annotations?.length) {
                 return;
             }
-            const clickedAnnotation = annotations.find((annotation) => this.isPointNearTool(element, annotation, eventDetail.currentPoints.canvas, 6));
+            const clickedAnnotation = annotations.find((annotation) => this.isPointNearTool(element, annotation, eventDetail.currentPoints.canvas, proximity));
             if (!clickedAnnotation) {
                 return;
             }

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

@@ -36,6 +36,7 @@ declare class ClickSegmentTool extends GrowCutBaseTool {
     private runConfinementDryRun;
     private probeAppliesToClick;
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    preTouchStartCallback: (evt: EventTypes.TouchStartEventType) => Promise<boolean>;
     private runClick;
     private fillWithRange;
     private indexToWorld;

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

@@ -52,6 +52,20 @@ class ClickSegmentTool extends GrowCutBaseTool {
         this.dryRunToken = null;
         this.confirmedRegion = null;
         this.rejectedRegions = [];
+        this.preTouchStartCallback = async (evt) => {
+            if (this.mode !== ToolModes.Active || this.segmentationInProgress) {
+                return false;
+            }
+            await this.runHoverProbe(evt);
+            if (this.lastProbe && !this.lastProbe.ok) {
+                growCutLog.info('tap ignored: probe reported no proper region', {
+                    canvasPoint: this.lastProbe.canvas,
+                });
+                this.notifySegmentationError('No meaningful region at the tapped location; nothing was segmented.');
+                return true;
+            }
+            return this.preMouseDownCallback(evt);
+        };
     }
     notifySegmentationError(message) {
         const event = new CustomEvent(CoreEnums.Events.ERROR_EVENT, {

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

@@ -2,6 +2,7 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg/index.js';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters/index.js';
 import { hideElementCursor } from '../../cursors/elementCursor.js';
+import { Events } from '../../enums/index.js';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds.js';
 import getViewportICamera from '../../utilities/getViewportICamera.js';
 import ProbeTool from './ProbeTool.js';
@@ -18,9 +19,10 @@ class DragProbeTool extends ProbeTool {
         this.postMouseDownCallback = (evt) => {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
-            const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
+            const isTouch = evt.type === Events.TOUCH_START;
+            const worldPos = this.getTouchAdjustedWorldPos(viewport, currentPoints, isTouch);
             this.isDrawing = true;
             const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;

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

@@ -29,6 +29,7 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
         contourHoleProcessingEnabled?: boolean;
     } | null;
     isDrawing: boolean;
+    handlesMultiTouchGestures: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     protected setupBaseEditData(worldPos: any, element: any, annotation: any, nextPos?: any, contourHoleProcessingEnabled?: any): void;
@@ -41,6 +42,8 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
     triggerChangeEvent: (annotation: LivewireContourAnnotation, enabledElement: Types.IEnabledElement, changeType?: ChangeTypes, contourHoleProcessingEnabled?: boolean) => void;
     private _mouseDownCallback;
     private _mouseMoveCallback;
+    private _touchDragDuringDrawCallback;
+    private _touchEndDuringDrawCallback;
     editHandle(worldPos: Types.Point3, element: any, annotation: LivewireContourAnnotation, handleIndex: number): void;
     protected _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     cancel: (element: HTMLDivElement) => string;

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

@@ -25,6 +25,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             preventHandleOutsideImage: false,
             contourHoleAdditionModifierKey: KeyboardBindings.Shift,
             snapHandleNearby: 2,
+            touchCloseCurveDistance: 36,
             interpolation: {
                 enabled: false,
                 nearestEdge: 2,
@@ -47,6 +48,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         },
     }) {
         super(toolProps, defaultToolProps);
+        this.handlesMultiTouchGestures = true;
         this.isHandleOutsideImage = false;
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
             const enabledElement = getEnabledElement(element);
@@ -137,7 +139,14 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             }
         };
         this._mouseDownCallback = (evt) => {
-            const doubleClick = evt.type === Events.MOUSE_DOUBLE_CLICK;
+            const isTouchEvent = evt.type === Events.TOUCH_TAP || evt.type === Events.TOUCH_END;
+            const doubleTap = evt.type === Events.TOUCH_TAP &&
+                evt.detail.taps >= 2;
+            const doubleClick = evt.type === Events.MOUSE_DOUBLE_CLICK || doubleTap;
+            if (doubleTap &&
+                this.isTouchTapEchoOfLiftCommit(evt.detail.currentPoints.canvas)) {
+                return;
+            }
             const { annotation, viewportIdsToRender, worldToSlice, sliceToWorld, newAnnotation, } = this.editData;
             if (this.editData.closed) {
                 return;
@@ -160,12 +169,15 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
                     index: -1,
                     distSquared: Infinity,
                 };
+                const closeDistSquared = isTouchEvent
+                    ? this.configuration.touchCloseCurveDistance ** 2
+                    : CLICK_CLOSE_CURVE_SQR_DIST;
                 for (let i = 0, len = controlPoints.length; i < len; i++) {
                     const controlPoint = controlPoints[i];
                     const worldControlPoint = sliceToWorld(controlPoint);
                     const canvasControlPoint = viewport.worldToCanvas(worldControlPoint);
                     const distSquared = math.point.distanceToPointSquared(canvasPos, canvasControlPoint);
-                    if (distSquared <= CLICK_CLOSE_CURVE_SQR_DIST &&
+                    if (distSquared <= closeDistSquared &&
                         distSquared < closestHandlePoint.distSquared) {
                         closestHandlePoint.distSquared = distSquared;
                         closestHandlePoint.index = i;
@@ -224,6 +236,24 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
+        this._touchDragDuringDrawCallback = (evt) => {
+            if (evt.detail.currentPointsList.length > 1) {
+                return;
+            }
+            this._mouseMoveCallback(evt);
+        };
+        this._touchEndDuringDrawCallback = (evt) => {
+            const { startPointsList, currentPointsList, startPoints, currentPoints } = evt.detail;
+            if (startPointsList.length > 1 || currentPointsList.length > 1) {
+                return;
+            }
+            const dragDistance = math.point.distanceToPoint(startPoints.canvas, currentPoints.canvas);
+            if (dragDistance <= LivewireContourTool.TOUCH_TAP_MAX_CANVAS_DISTANCE) {
+                return;
+            }
+            this.recordTouchLiftCommit(currentPoints.canvas);
+            this._mouseDownCallback(evt);
+        };
         this._dragCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
@@ -274,6 +304,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             element.addEventListener(Events.MOUSE_DOWN, this._mouseDownCallback);
             element.addEventListener(Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.addEventListener(Events.TOUCH_TAP, this._mouseDownCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._touchDragDuringDrawCallback);
+            element.addEventListener(Events.TOUCH_END, this._touchEndDuringDrawCallback);
         };
         this._deactivateDraw = (element) => {
             state.isInteractingWithTool = false;
@@ -281,6 +313,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             element.removeEventListener(Events.MOUSE_DOWN, this._mouseDownCallback);
             element.removeEventListener(Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.removeEventListener(Events.TOUCH_TAP, this._mouseDownCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._touchDragDuringDrawCallback);
+            element.removeEventListener(Events.TOUCH_END, this._touchEndDuringDrawCallback);
         };
         this._calculateCachedStats = (annotation, element) => {
             if (!this.configuration.calculateStats) {

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base/index.js';
 import { ChangeTypes } from '../../enums/index.js';
-import type { EventTypes, ToolHandle, PublicToolProps, SVGDrawingHelper } from '../../types/index.js';
+import type { EventTypes, ToolHandle, PublicToolProps, SVGDrawingHelper, InteractionTypes } from '../../types/index.js';
 import type { ProbeAnnotation } from '../../types/ToolSpecificAnnotationTypes.js';
 declare class ProbeTool extends AnnotationTool {
     static toolName: string;
@@ -16,6 +16,10 @@ declare class ProbeTool extends AnnotationTool {
                 x: number;
                 y: number;
             };
+            touchCanvasOffset: {
+                x: number;
+                y: number;
+            };
         };
     };
     constructor(toolProps?: PublicToolProps, defaultToolProps?: any);
@@ -28,8 +32,12 @@ declare class ProbeTool extends AnnotationTool {
         viewplaneNormal?: Types.Point3;
         viewUp?: Types.Point3;
     }) => ProbeAnnotation;
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => ProbeAnnotation;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType, interactionType?: InteractionTypes) => ProbeAnnotation;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: ProbeAnnotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
+    protected getTouchAdjustedWorldPos(viewport: Types.IViewport, currentPoints: {
+        canvas: Types.Point2;
+        world: Types.Point3;
+    }, isTouch: boolean): Types.Point3;
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: ProbeAnnotation): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: any) => void;

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

@@ -20,12 +20,13 @@ const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps) {
         super(toolProps, AnnotationTool.mergeDefaultProps(_a.probeDefaults, defaultToolProps));
-        this.addNewAnnotation = (evt) => {
+        this.addNewAnnotation = (evt, interactionType = 'Mouse') => {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
-            const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
+            const isTouch = interactionType.toLowerCase() === 'touch';
+            const worldPos = this.getTouchAdjustedWorldPos(viewport, currentPoints, isTouch);
             this.isDrawing = true;
             const annotation = (this.constructor).createAnnotationForViewport(viewport, {
                 data: {
@@ -75,7 +76,9 @@ class ProbeTool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
-            const worldPos = currentPoints.world;
+            const { viewport } = getEnabledElement(element);
+            const isTouch = evt.type === Events.TOUCH_DRAG;
+            const worldPos = this.getTouchAdjustedWorldPos(viewport, currentPoints, isTouch);
             const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
             const { data } = annotation;
             this.createMemo(element, annotation, { newAnnotation });
@@ -231,6 +234,18 @@ class ProbeTool extends AnnotationTool {
             return point;
         }
     }
+    getTouchAdjustedWorldPos(viewport, currentPoints, isTouch) {
+        const { touchCanvasOffset } = this.configuration;
+        if (!isTouch || !touchCanvasOffset) {
+            return currentPoints.world;
+        }
+        const { x = 0, y = 0 } = touchCanvasOffset;
+        if (!x && !y) {
+            return currentPoints.world;
+        }
+        const [canvasX, canvasY] = currentPoints.canvas;
+        return viewport.canvasToWorld([canvasX + x, canvasY + y]);
+    }
     handleSelectedCallback(evt, annotation) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;
@@ -336,6 +351,10 @@ ProbeTool.probeDefaults = {
             x: 6,
             y: -6,
         },
+        touchCanvasOffset: {
+            x: 0,
+            y: -40,
+        },
     },
 };
 ProbeTool.hydrate = (viewportId, points, options) => {

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

@@ -40,6 +40,9 @@ class RegionSegmentTool extends GrowCutBaseTool {
             element.removeEventListener(Events.MOUSE_UP, this._endCallback);
             element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
             element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
         };
     }
     async preMouseDownCallback(evt) {
@@ -84,6 +87,9 @@ class RegionSegmentTool extends GrowCutBaseTool {
         element.addEventListener(Events.MOUSE_UP, this._endCallback);
         element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
         element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+        element.addEventListener(Events.TOUCH_END, this._endCallback);
+        element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+        element.addEventListener(Events.TOUCH_TAP, this._endCallback);
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
         if (!this.growCutData) {

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

@@ -28,9 +28,11 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
         newAnnotation?: boolean;
         hasMoved?: boolean;
         lastCanvasPoint?: Types.Point2;
+        closeCurveDistance?: number;
         contourHoleProcessingEnabled?: boolean;
     } | null;
     isDrawing: boolean;
+    handlesMultiTouchGestures: boolean;
     isHandleOutsideImage: boolean;
     fireChangeOnUpdate: {
         annotationUID: string;
@@ -52,6 +54,8 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     private _keyDownCallback;
     private _mouseMoveCallback;
     private _mouseDownCallback;
+    private _touchDragDuringDrawCallback;
+    private _touchEndDuringDrawCallback;
     protected _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     cancel(element: HTMLDivElement): string;
     triggerAnnotationCompleted: (annotation: SplineROIAnnotation, contourHoleProcessingEnabled: boolean) => void;