@cornerstonejs/tools 5.6.14 → 5.7.1

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

@@ -82,6 +82,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 type: SplineTypesEnum.CatmullRom,
                 drawPreviewEnabled: true,
                 enableTwoPointPreview: false,
+                touchCloseCurveDistance: 36,
                 lastControlPointDeletionKeys: ['Backspace', 'Delete'],
             },
             actions: {
@@ -113,6 +114,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
             'BSplineROI',
             'CardinalSplineROI',
         ];
+        this.handlesMultiTouchGestures = true;
         this.isHandleOutsideImage = false;
         this.fireChangeOnUpdate = null;
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
@@ -229,11 +231,22 @@ class SplineROITool extends ContourSegmentationBaseTool {
             const { renderingEngine } = getEnabledElement(element);
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
             this.editData.lastCanvasPoint = evt.detail.currentPoints.canvas;
+            this.editData.closeCurveDistance =
+                evt.type === Events.TOUCH_DRAG
+                    ? this.configuration.spline.touchCloseCurveDistance
+                    : SPLINE_CLICK_CLOSE_CURVE_DIST;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
         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 } = this.editData;
             const { data } = annotation;
             if (data.contour.closed) {
@@ -255,7 +268,10 @@ class SplineROITool extends ContourSegmentationBaseTool {
             if (data.handles.points.length >= 3) {
                 this.createMemo(element, annotation);
                 const { instance: spline } = data.spline;
-                const closestControlPoint = spline.getClosestControlPointWithinDistance(canvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
+                const closeCurveDistance = isTouchEvent
+                    ? this.configuration.spline.touchCloseCurveDistance
+                    : SPLINE_CLICK_CLOSE_CURVE_DIST;
+                const closestControlPoint = spline.getClosestControlPointWithinDistance(canvasPoint, closeCurveDistance);
                 if (closestControlPoint?.index === 0) {
                     addNewPoint = false;
                     closeContour = !this.configuration.allowOpenSplines;
@@ -275,6 +291,24 @@ class SplineROITool extends ContourSegmentationBaseTool {
             }
             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 <= _a.TOUCH_TAP_MAX_CANVAS_DISTANCE) {
+                return;
+            }
+            this.recordTouchLiftCommit(currentPoints.canvas);
+            this._mouseDownCallback(evt);
+        };
         this._dragCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
@@ -343,6 +377,8 @@ class SplineROITool 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;
@@ -351,6 +387,8 @@ class SplineROITool 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._renderStats = (annotation, enabledElement, svgDrawingHelper) => {
             const data = annotation.data;
@@ -631,7 +669,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 });
             }
             else if (spline.numControlPoints > 1) {
-                const previewPolylinePoints = spline.getPreviewPolylinePoints(lastCanvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
+                const previewPolylinePoints = spline.getPreviewPolylinePoints(lastCanvasPoint, this.editData?.closeCurveDistance ?? SPLINE_CLICK_CLOSE_CURVE_DIST);
                 drawPolylineSvg(svgDrawingHelper, annotationUID, 'previewSplineChange', previewPolylinePoints, {
                     color: '#9EA0CA',
                     lineDash: lineDash,

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

@@ -40,8 +40,8 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
             const { element } = eventData;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            await this.runGrowCut();
             this._deactivateDraw(element);
+            await this.runGrowCut();
             this.growCutData = null;
             resetElementCursor(element);
             triggerAnnotationRenderForViewportUIDs([viewport.id]);
@@ -50,6 +50,9 @@ class WholeBodySegmentTool 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) {
@@ -152,6 +155,9 @@ class WholeBodySegmentTool 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);
     }
     _projectWorldPointAcrossSlices(viewport, worldEdgePoint, vecDirection) {
         const volume = this._getViewportVolume(viewport);

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

@@ -2,11 +2,16 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes.js';
 import type StrategyCallbacks from '../../enums/StrategyCallbacks.js';
-import type { InteractionTypes, ToolProps, PublicToolProps, ToolConfiguration, AnnotationData, MeasurementTargetCandidate } from '../../types/index.js';
+import type { EventTypes, InteractionTypes, ToolProps, PublicToolProps, ToolConfiguration, AnnotationData, MeasurementTargetCandidate } from '../../types/index.js';
 declare abstract class BaseTool {
     static toolName: any;
     static activeCursorTool: any;
+    static readonly TOUCH_PROXIMITY = 36;
+    static readonly MOUSE_PROXIMITY = 6;
+    static readonly TOUCH_TAP_MAX_CANVAS_DISTANCE = 24;
+    static readonly TOUCH_TAP_TOLERANCE_MS = 300;
     supportedInteractionTypes: InteractionTypes[];
+    handlesMultiTouchGestures: boolean;
     configuration: Record<string, any>;
     get configurationTyped(): ToolConfiguration;
     toolGroupId: string;
@@ -32,6 +37,7 @@ declare abstract class BaseTool {
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string, ...extraArgs: any[]): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
+    protected _isTouchInteraction(evt?: EventTypes.InteractionEventType): boolean;
     protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
     protected getTargetId(viewport: Types.IViewport, data?: AnnotationData): string | undefined;
     protected getMeasurementTargets(viewport: Types.IViewport, data?: AnnotationData): string[];

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

@@ -1,5 +1,7 @@
 import { cache, metaData, utilities as csUtils, viewportHasPan, viewportHasZoom, } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes.js';
+import Events from '../../enums/Events.js';
+import { MOUSE_PROXIMITY, TOUCH_PROXIMITY, TOUCH_TAP_MAX_CANVAS_DISTANCE, TOUCH_TAP_TOLERANCE_MS, } from '../../utilities/touch/constants.js';
 import measurementTargetFilters from './measurementTargetFilters.js';
 const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class BaseTool {
@@ -7,6 +9,7 @@ class BaseTool {
         return this.configuration;
     }
     constructor(toolProps, defaultToolProps) {
+        this.handlesMultiTouchGestures = false;
         this.isPrimary = false;
         const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
         const initialProps = csUtils.deepMerge(mergedDefaults, toolProps);
@@ -50,6 +53,15 @@ class BaseTool {
     setActiveStrategy(strategyName) {
         this.setConfiguration({ activeStrategy: strategyName });
     }
+    _isTouchInteraction(evt) {
+        const eventName = evt?.detail?.eventName;
+        return (eventName === Events.TOUCH_START ||
+            eventName === Events.TOUCH_START_ACTIVATE ||
+            eventName === Events.TOUCH_DRAG ||
+            eventName === Events.TOUCH_END ||
+            eventName === Events.TOUCH_TAP ||
+            eventName === Events.TOUCH_PRESS);
+    }
     getTargetImageData(targetId) {
         if (targetId.startsWith('imageId:')) {
             const imageId = targetId.split('imageId:')[1];
@@ -293,6 +305,10 @@ class BaseTool {
         return true;
     }
 }
+BaseTool.TOUCH_PROXIMITY = TOUCH_PROXIMITY;
+BaseTool.MOUSE_PROXIMITY = MOUSE_PROXIMITY;
+BaseTool.TOUCH_TAP_MAX_CANVAS_DISTANCE = TOUCH_TAP_MAX_CANVAS_DISTANCE;
+BaseTool.TOUCH_TAP_TOLERANCE_MS = TOUCH_TAP_TOLERANCE_MS;
 BaseTool.defaults = {
     configuration: {
         strategies: {},

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

@@ -1,10 +1,14 @@
+import type { Types } from '@cornerstonejs/core';
 import type { Annotation, EventTypes, PublicToolProps, ToolProps, AnnotationRenderContext, Annotations } from '../../types/index.js';
 import type { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes.js';
 import type { StyleSpecifier } from '../../types/AnnotationStyle.js';
 import ContourBaseTool from './ContourBaseTool.js';
 declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     static PreviewSegmentIndex: number;
+    private _touchLiftCommit?;
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    protected recordTouchLiftCommit(canvasPoint: Types.Point2): void;
+    protected isTouchTapEchoOfLiftCommit(canvasPoint: Types.Point2): boolean;
     protected onSetToolConfiguration(): void;
     protected isContourSegmentationTool(): boolean;
     protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;

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

@@ -1,4 +1,5 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { distanceToPoint } from '../../utilities/math/point/index.js';
 import { SegmentationRepresentations } from '../../enums/index.js';
 import ContourBaseTool from './ContourBaseTool.js';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents.js';
@@ -20,6 +21,28 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             InterpolationManager.addTool(this.getToolName());
         }
     }
+    recordTouchLiftCommit(canvasPoint) {
+        this._touchLiftCommit = { canvasPoint, time: Date.now() };
+    }
+    isTouchTapEchoOfLiftCommit(canvasPoint) {
+        if (!this._touchLiftCommit) {
+            return false;
+        }
+        const { canvasPoint: committedPoint, time } = this._touchLiftCommit;
+        const withinTime = Date.now() - time <=
+            2 * ContourSegmentationBaseTool.TOUCH_TAP_TOLERANCE_MS;
+        if (!withinTime) {
+            this._touchLiftCommit = undefined;
+            return false;
+        }
+        const withinDistance = distanceToPoint(canvasPoint, committedPoint) <=
+            ContourSegmentationBaseTool.TOUCH_TAP_MAX_CANVAS_DISTANCE;
+        if (!withinDistance) {
+            return false;
+        }
+        this._touchLiftCommit = undefined;
+        return true;
+    }
     onSetToolConfiguration() {
         if (this.configuration.interpolation?.enabled) {
             InterpolationManager.addTool(this.getToolName());

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

@@ -4,6 +4,7 @@ import LabelmapBaseTool from './LabelmapBaseTool.js';
 declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
     private _lastDragInfo;
+    private _drawStartTimeStamp;
     private _lazyEdit;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     onSetToolPassive: (_evt: any) => void;
@@ -20,7 +21,9 @@ declare class BrushTool extends LabelmapBaseTool {
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
     previewCallback: () => void;
     protected updateCursor(evt: EventTypes.InteractionEventType): void;
+    private _clearCursor;
     private _dragCallback;
+    protected _cancelTouchDraw(element: HTMLDivElement): void;
     private _calculateCursor;
     private _endCallback;
     getStatistics(element: any, segmentIndices?: any): any;

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

@@ -83,6 +83,7 @@ class BrushTool extends LabelmapBaseTool {
     }) {
         super(toolProps, defaultToolProps);
         this._lastDragInfo = null;
+        this._drawStartTimeStamp = 0;
         this._lazyEdit = new LazyBrushEditController();
         this.onSetToolPassive = (_evt) => {
             this.disableCursor();
@@ -113,6 +114,7 @@ class BrushTool extends LabelmapBaseTool {
             this._editData = this.createEditData(element);
             this._previewData.isDrag = false;
             this._previewData.timerStart = Date.now();
+            this._drawStartTimeStamp = eventData.event?.timeStamp ?? 0;
             const canvasPoint = vec2.clone(currentPoints.canvas);
             const worldPoint = viewport.canvasToWorld([
                 canvasPoint[0],
@@ -128,6 +130,7 @@ class BrushTool extends LabelmapBaseTool {
                 return false;
             }
             this._calculateCursor(element, canvasPoint);
+            BrushTool.activeCursorTool = this;
             this._resetLazyEditState();
             if (this._isLazyLabelmapEditingEnabled(this._hoverData.viewport)) {
                 this._lazyEdit.appendStrokePoint(worldPoint);
@@ -217,6 +220,11 @@ class BrushTool extends LabelmapBaseTool {
         this._dragCallback = (evt) => {
             const eventData = evt.detail;
             const { element, currentPoints } = eventData;
+            const { currentPointsList } = eventData;
+            if (currentPointsList?.length > 1) {
+                this._cancelTouchDraw(element);
+                return;
+            }
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.updateCursor(evt);
@@ -286,6 +294,12 @@ class BrushTool extends LabelmapBaseTool {
         this._endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
+            if (eventData.eventName === Events.TOUCH_TAP) {
+                const tapTimeStamp = eventData.event?.timeStamp ?? 0;
+                if (tapTimeStamp < this._drawStartTimeStamp) {
+                    return;
+                }
+            }
             const enabledElement = getEnabledElement(element);
             const operationData = this.getOperationData(element);
             if (!operationData) {
@@ -307,12 +321,17 @@ class BrushTool extends LabelmapBaseTool {
             this._editData = null;
             this._lastDragInfo = null;
             if (isLazyLabelmapEditing && this._previewData.isDrag) {
-                this._scheduleLazyPreviewCleanup(element, evt.detail.currentPoints.canvas, enabledElement.viewport.id, operationData.segmentationId);
+                this._scheduleLazyPreviewCleanup(element, evt.detail.currentPoints.canvas, enabledElement.viewport.id, operationData.segmentationId, this._isTouchInteraction(evt));
                 triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
             }
             else {
                 this._resetLazyEditState();
-                this.updateCursor(evt);
+                if (this._isTouchInteraction(evt)) {
+                    this._clearCursor(element);
+                }
+                else {
+                    this.updateCursor(evt);
+                }
             }
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionEnd);
             if (!this._previewData.isDrag) {
@@ -323,11 +342,17 @@ class BrushTool extends LabelmapBaseTool {
             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);
         };
         this._deactivateDraw = (element) => {
             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);
         };
     }
     disableCursor() {
@@ -354,13 +379,15 @@ class BrushTool extends LabelmapBaseTool {
         BrushTool.activeCursorTool = this;
         triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
     }
-    _scheduleLazyPreviewCleanup(element, centerCanvas, viewportId, segmentationId) {
+    _scheduleLazyPreviewCleanup(element, centerCanvas, viewportId, segmentationId, isTouch = false) {
         this._lazyEdit.scheduleCleanup({
             element,
             centerCanvas,
             viewportId,
             segmentationId,
-            refreshCursor: this._refreshCursor.bind(this),
+            refreshCursor: isTouch
+                ? (cleanupElement) => this._clearCursor(cleanupElement)
+                : this._refreshCursor.bind(this),
         });
     }
     _captureLazyPreviewCircle() {
@@ -376,6 +403,37 @@ class BrushTool extends LabelmapBaseTool {
         const centerCanvas = currentPoints.canvas;
         this._refreshCursor(element, centerCanvas);
     }
+    _clearCursor(element) {
+        const viewportIdsToRender = this._hoverData?.viewportIdsToRender;
+        this._hoverData = undefined;
+        if (viewportIdsToRender?.length) {
+            triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        if (enabledElement) {
+            triggerAnnotationRenderForViewportUIDs([enabledElement.viewport.id]);
+        }
+    }
+    _cancelTouchDraw(element) {
+        const { memo } = this;
+        if (memo?.commitMemo?.()) {
+            memo.restoreMemo(true);
+        }
+        this.memo = null;
+        this._deactivateDraw(element);
+        resetElementCursor(element);
+        this._editData = null;
+        this._lastDragInfo = null;
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+        if (this._previewData.timer) {
+            window.clearTimeout(this._previewData.timer);
+            this._previewData.timer = null;
+        }
+        this._resetLazyEditState();
+        this._clearCursor(element);
+    }
     _calculateCursor(element, _centerCanvas) {
         const enabledElement = getEnabledElement(element);
         const operationData = this.getOperationData(element);

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

@@ -123,9 +123,14 @@ class CircleScissorsTool extends LabelmapBaseTool {
             return true;
         };
         this._dragCallback = (evt) => {
-            this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
+            const { currentPointsList } = eventDetail;
+            if (currentPointsList?.length > 1) {
+                this._cancelTouchDraw(element);
+                return;
+            }
+            this.isDrawing = true;
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);

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

@@ -58,6 +58,10 @@ export default class LabelmapBaseTool extends BaseTool {
         viewport: Types.IViewport;
     };
     static previewData?: PreviewData;
+    protected isDrawing?: boolean;
+    protected editData?: {
+        viewportIdsToRender?: string[];
+    } | null;
     protected memoMap: Map<string, LabelmapMemo.LabelmapMemo>;
     protected acceptedMemoIds: Map<string, {
         element: HTMLDivElement;
@@ -65,6 +69,7 @@ export default class LabelmapBaseTool extends BaseTool {
     }>;
     protected memo: LabelmapMemo.LabelmapMemo;
     constructor(toolProps: any, defaultToolProps: any);
+    protected _cancelTouchDraw(element: HTMLDivElement): void;
     protected _historyRedoHandler(evt: any): void;
     protected get _previewData(): PreviewData;
     hasPreviewData(): boolean;

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

@@ -17,6 +17,8 @@ import { fillInsideCircle } from './strategies/index.js';
 import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode.js';
 import { getOrCreateLabelmapVolume, resolveLabelmapForSegment, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState.js';
 import getViewportICamera from '../../utilities/getViewportICamera.js';
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds.js';
+import { resetElementCursor } from '../../cursors/elementCursor.js';
 class LabelmapBaseTool extends BaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -29,6 +31,19 @@ class LabelmapBaseTool extends BaseTool {
             changedIndices: [],
         };
     }
+    _cancelTouchDraw(element) {
+        if (!this.isDrawing) {
+            return;
+        }
+        const viewportIdsToRender = this.editData?.viewportIdsToRender;
+        this._deactivateDraw(element);
+        resetElementCursor(element);
+        this.editData = null;
+        this.isDrawing = false;
+        if (viewportIdsToRender) {
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        }
+    }
     _historyRedoHandler(evt) {
         const { id, operationType } = evt.detail;
         if (operationType !== 'labelmap') {

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

@@ -20,6 +20,7 @@ import { getPixelValueUnits } from '../../utilities/getPixelValueUnits.js';
 const { transformWorldToIndex } = csUtils;
 class RectangleROIStartEndThresholdTool extends RectangleROITool {
     constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             storePointData: false,
             numSlicesToPropagate: 10,

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

@@ -115,9 +115,14 @@ class RectangleScissorsTool extends LabelmapBaseTool {
             return true;
         };
         this._dragCallback = (evt) => {
-            this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
+            const { currentPointsList } = eventDetail;
+            if (currentPointsList?.length > 1) {
+                this._cancelTouchDraw(element);
+                return;
+            }
+            this.isDrawing = true;
             const { annotation, viewportIdsToRender, handleIndex } = this.editData;
             const { data } = annotation;
             const { currentPoints } = eventDetail;

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

@@ -23,7 +23,7 @@ class SegmentLabelTool extends BaseTool {
             },
         },
     }, defaultToolProps = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
+        supportedInteractionTypes: ['Mouse'],
         configuration: {
             hoverTimeout: 100,
             searchRadius: 6,

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

@@ -9,7 +9,7 @@ import { state } from '../../store/state.js';
 import { ToolModes } from '../../enums/index.js';
 class SegmentSelectTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
+        supportedInteractionTypes: ['Mouse'],
         configuration: {
             hoverTimeout: 100,
             mode: SegmentSelectTool.SelectMode.Border,

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

@@ -110,9 +110,14 @@ class SphereScissorsTool extends LabelmapBaseTool {
             return true;
         };
         this._dragCallback = (evt) => {
-            this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
+            const { currentPointsList } = eventDetail;
+            if (currentPointsList?.length > 1) {
+                this._cancelTouchDraw(element);
+                return;
+            }
+            this.isDrawing = true;
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);

package/dist/esm/utilities/touch/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const TOUCH_PROXIMITY = 36;
+export declare const MOUSE_PROXIMITY = 6;
+export declare const TOUCH_TAP_MAX_CANVAS_DISTANCE = 24;
+export declare const TOUCH_TAP_TOLERANCE_MS = 300;

package/dist/esm/utilities/touch/constants.js

@@ -0,0 +1,4 @@
+export const TOUCH_PROXIMITY = 36;
+export const MOUSE_PROXIMITY = 6;
+export const TOUCH_TAP_MAX_CANVAS_DISTANCE = 24;
+export const TOUCH_TAP_TOLERANCE_MS = 300;

package/dist/esm/utilities/touch/index.d.ts

@@ -7,4 +7,6 @@ declare function copyPointsList(points: ITouchPoints[]): ITouchPoints[];
 declare function copyPoints(points: ITouchPoints): ITouchPoints;
 declare function getMeanPoints(points: IPoints[]): IPoints;
 declare function getMeanTouchPoints(points: ITouchPoints[]): ITouchPoints;
-export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, };
+declare function isMobile(): boolean;
+export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, isMobile, };
+export { TOUCH_PROXIMITY, MOUSE_PROXIMITY, TOUCH_TAP_MAX_CANVAS_DISTANCE, TOUCH_TAP_TOLERANCE_MS, } from './constants.js';

package/dist/esm/utilities/touch/index.js

@@ -150,4 +150,10 @@ function _getDistance3D(point0, point1) {
         Math.pow(point0[1] - point1[1], 2) +
         Math.pow(point0[2] - point1[2], 2));
 }
-export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, };
+function isMobile() {
+    return (typeof window !== 'undefined' &&
+        typeof window.matchMedia === 'function' &&
+        window.matchMedia('(any-pointer:coarse)').matches);
+}
+export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, isMobile, };
+export { TOUCH_PROXIMITY, MOUSE_PROXIMITY, TOUCH_TAP_MAX_CANVAS_DISTANCE, TOUCH_TAP_TOLERANCE_MS, } from './constants.js';

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.6.14";
+export declare const version = "5.7.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.6.14';
+export const version = '5.7.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "5.6.14",
+  "version": "5.7.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -126,11 +126,11 @@
     "lodash.get": "4.4.2"
   },
   "devDependencies": {
-    "@cornerstonejs/core": "5.6.14",
+    "@cornerstonejs/core": "5.7.1",
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "5.6.14",
+    "@cornerstonejs/core": "5.7.1",
     "@kitware/vtk.js": "36.4.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -149,5 +149,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "28a786f97cef363f62f94f38e95d03f4bcccba2e"
+  "gitHead": "14841bb671002953b4d98da0333c65dc8e8156ef"
 }