@cornerstonejs/tools 5.4.17 → 5.5.1

package/dist/esm/tools/WorldCrosshairTool.js

@@ -0,0 +1,749 @@
+import { vec3 } from 'gl-matrix';
+import { getEnabledElement, getEnabledElementByIds, getEnabledElementByViewportId, eventTarget, triggerEvent, utilities as csUtils, Enums, } from '@cornerstonejs/core';
+import { AnnotationTool } from './base/index.js';
+import { getToolGroup } from '../store/ToolGroupManager/index.js';
+import { state } from '../store/state.js';
+import { Events } from '../enums/index.js';
+import { addAnnotation, removeAnnotation, } from '../stateManagement/annotation/annotationState.js';
+import { drawCircle as drawCircleSvg, drawLine as drawLineSvg, drawTextBox as drawTextBoxSvg, } from '../drawingSvg/index.js';
+import { resetElementCursor, hideElementCursor, } from '../cursors/elementCursor.js';
+import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds.js';
+import getViewportICamera from '../utilities/getViewportICamera.js';
+import { navigatePlanarViewportToPoint } from '../utilities/genericViewportToolHelpers.js';
+import { getViewportPlane, distancePointToPlane, projectPointToPlane, getDisplayedCanvasSize, } from '../utilities/spatial/index.js';
+import pickIntensityPointInSlab from '../utilities/pickIntensityPointInSlab.js';
+import { updateWorldCrosshairLines3D, removeWorldCrosshairLines3D, } from './worldCrosshair/WorldCrosshairLines3D.js';
+const { ViewportType } = Enums;
+const POINT_EPSILON = 1e-4;
+const JUMP_EPSILON = 1e-6;
+function isFinitePoint3(point) {
+    return (Array.isArray(point) &&
+        point.length === 3 &&
+        point.every((v) => Number.isFinite(v)));
+}
+function parseCssColorToRGB(color) {
+    if (typeof color === 'string') {
+        const rgbMatch = color.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+        if (rgbMatch) {
+            return [
+                Number(rgbMatch[1]) / 255,
+                Number(rgbMatch[2]) / 255,
+                Number(rgbMatch[3]) / 255,
+            ];
+        }
+        const hexMatch = color.match(/^#([0-9a-f]{6})$/i);
+        if (hexMatch) {
+            const hex = parseInt(hexMatch[1], 16);
+            return [
+                ((hex >> 16) & 255) / 255,
+                ((hex >> 8) & 255) / 255,
+                (hex & 255) / 255,
+            ];
+        }
+    }
+    return [1, 1, 0];
+}
+class WorldCrosshairTool extends AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            pointColor: 'rgb(255, 255, 0)',
+            pointRadius: 4,
+            markerStyle: 'crosshair',
+            centerGapRadius: 12,
+            offSliceDisplay: 'projectedWithDistance',
+            offSliceToleranceMm: 0.5,
+            autoInitializeOnEnable: true,
+            clickToSet: false,
+            snapToSlabIntensity: true,
+            jumpOnSet: true,
+            jumpMode: 'sliceOnly',
+            preservePanZoom: true,
+            liveUpdateOnShiftMouseMove: true,
+            liveJumpOnShiftMouseMove: true,
+            showIn2D: true,
+            showIn3D: true,
+            threeDViewportIds: [],
+            threeDLineLengthMm: 100,
+            linkPolicy: 'frameOfReferenceUID',
+            explicitLinkedViewportIds: [],
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._state = {
+            worldPoint: null,
+            visible: true,
+            locked: false,
+            cursorWorldPoint: null,
+        };
+        this._annotation = null;
+        this._isDragging = false;
+        this._autoInitialized = false;
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { element, currentPoints } = eventDetail;
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement || this._state.locked) {
+                return this._getAnnotationOrDetached();
+            }
+            const nativeEvent = eventDetail.event;
+            if (!this.configuration.clickToSet && !nativeEvent?.shiftKey) {
+                return this._getAnnotationOrDetached();
+            }
+            const { viewport, renderingEngine, FrameOfReferenceUID } = enabledElement;
+            if (!this._isPlanarViewport(viewport)) {
+                return this._getAnnotationOrDetached();
+            }
+            this.setWorldPoint(this._resolveInteractionWorldPoint(viewport, currentPoints.world), {
+                sourceViewportId: viewport.id,
+                sourceRenderingEngineId: renderingEngine?.id,
+                frameOfReferenceUID: FrameOfReferenceUID,
+            });
+            evt.preventDefault();
+            hideElementCursor(element);
+            this._startDrag(element);
+            return this._getAnnotationOrDetached();
+        };
+        this.toolSelectedCallback = (evt, annotation) => {
+            const { element } = evt.detail;
+            if (this._state.locked) {
+                return;
+            }
+            annotation.highlighted = true;
+            hideElementCursor(element);
+            this._startDrag(element);
+            evt.preventDefault();
+        };
+        this.handleSelectedCallback = (evt, annotation, _handle, _interactionType = 'Mouse') => {
+            this.toolSelectedCallback(evt, annotation);
+        };
+        this.doubleClickCallback = (evt) => {
+            const { element, currentPoints } = evt.detail;
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement || !this._state.worldPoint) {
+                return;
+            }
+            const markerCanvas = this._getMarkerCanvasPosition(enabledElement.viewport);
+            if (!markerCanvas) {
+                return;
+            }
+            const distance = Math.hypot(markerCanvas[0] - currentPoints.canvas[0], markerCanvas[1] - currentPoints.canvas[1]);
+            if (distance > this.configuration.pointRadius + 6) {
+                return;
+            }
+            this.jumpLinkedViewportsToWorldPoint();
+            evt.preventDefault();
+        };
+        this.mouseMoveCallback = (evt, filteredToolAnnotations) => {
+            const { element, currentPoints } = evt.detail;
+            const nativeEvent = evt.detail.event;
+            let needsRedraw = false;
+            if (this.configuration.liveUpdateOnShiftMouseMove &&
+                nativeEvent?.shiftKey &&
+                !this._state.locked) {
+                const enabledElement = getEnabledElement(element);
+                const viewport = enabledElement?.viewport;
+                if (viewport && this._isPlanarViewport(viewport)) {
+                    this._state.cursorWorldPoint = [
+                        currentPoints.world[0],
+                        currentPoints.world[1],
+                        currentPoints.world[2],
+                    ];
+                    this.setWorldPoint(this._resolveInteractionWorldPoint(viewport, currentPoints.world), {
+                        sourceViewportId: viewport.id,
+                        sourceRenderingEngineId: enabledElement.renderingEngine?.id,
+                        frameOfReferenceUID: enabledElement.FrameOfReferenceUID,
+                        jump: this.configuration.liveJumpOnShiftMouseMove,
+                    });
+                    needsRedraw = true;
+                }
+            }
+            if (filteredToolAnnotations?.length) {
+                for (const annotation of filteredToolAnnotations) {
+                    const near = this.isPointNearTool(element, annotation, currentPoints.canvas, 6, 'mouse');
+                    if (near !== !!annotation.highlighted) {
+                        annotation.highlighted = near;
+                        needsRedraw = true;
+                    }
+                }
+            }
+            return needsRedraw;
+        };
+        this.isPointNearTool = (element, _annotation, canvasCoords, proximity, _interactionType) => {
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement) {
+                return false;
+            }
+            const markerCanvas = this._getMarkerCanvasPosition(enabledElement.viewport);
+            if (!markerCanvas) {
+                return false;
+            }
+            const distance = Math.hypot(markerCanvas[0] - canvasCoords[0], markerCanvas[1] - canvasCoords[1]);
+            return distance <= this.configuration.pointRadius + proximity;
+        };
+        this.filterInteractableAnnotationsForElement = (element, annotations) => {
+            if (!annotations?.length || !this._state.worldPoint) {
+                return [];
+            }
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement ||
+                !this._getMarkerCanvasPosition(enabledElement.viewport)) {
+                return [];
+            }
+            return annotations.filter((annotation) => annotation.metadata.toolName === this.getToolName());
+        };
+        this.cancel = (element) => {
+            if (this._isDragging) {
+                this._isDragging = false;
+                this._deactivateModify(element);
+                resetElementCursor(element);
+            }
+        };
+        this._dragCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element, currentPoints } = eventDetail;
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement || this._state.locked) {
+                return;
+            }
+            const { viewport, renderingEngine, FrameOfReferenceUID } = enabledElement;
+            if (!this._isPlanarViewport(viewport)) {
+                return;
+            }
+            this._state.cursorWorldPoint = [
+                currentPoints.world[0],
+                currentPoints.world[1],
+                currentPoints.world[2],
+            ];
+            this.setWorldPoint(this._resolveInteractionWorldPoint(viewport, currentPoints.world), {
+                sourceViewportId: viewport.id,
+                sourceRenderingEngineId: renderingEngine?.id,
+                frameOfReferenceUID: FrameOfReferenceUID,
+            });
+        };
+        this._endCallback = (evt) => {
+            const { element } = evt.detail;
+            this._isDragging = false;
+            this._deactivateModify(element);
+            resetElementCursor(element);
+            this._state.cursorWorldPoint = null;
+            this._renderLinkedViewports();
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            this._maybeAutoInitialize(enabledElement);
+            const { viewport } = enabledElement;
+            const { worldPoint, visible } = this._state;
+            const { showIn2D, pointColor, pointRadius, markerStyle, offSliceDisplay, offSliceToleranceMm, } = this.configuration;
+            if (!worldPoint || !visible || !showIn2D) {
+                return false;
+            }
+            if (!this._isPlanarViewport(viewport)) {
+                return false;
+            }
+            if (!this._isViewportLinked(viewport)) {
+                return false;
+            }
+            const plane = getViewportPlane(viewport);
+            if (!plane) {
+                return false;
+            }
+            const distanceMm = distancePointToPlane(worldPoint, plane);
+            const projectedPoint = projectPointToPlane(worldPoint, plane);
+            const canvasPoint = viewport.worldToCanvas(projectedPoint);
+            if (!canvasPoint || !canvasPoint.every((c) => Number.isFinite(c))) {
+                return false;
+            }
+            const toleranceMm = this._getEffectiveOffSliceTolerance(viewport, plane, offSliceToleranceMm);
+            const inSlice = Math.abs(distanceMm) <= toleranceMm;
+            if (!inSlice && offSliceDisplay === 'hide') {
+                return false;
+            }
+            const annotationUID = this._annotation?.annotationUID ?? `WorldCrosshair-${this.toolGroupId}`;
+            const highlighted = !!this._annotation?.highlighted;
+            const lineOptions = {
+                color: pointColor,
+                width: highlighted ? 2 : 1,
+                ...(inSlice ? {} : { lineDash: '3,3', strokeOpacity: 0.7 }),
+            };
+            if (markerStyle === 'point') {
+                drawCircleSvg(svgDrawingHelper, annotationUID, 'marker', canvasPoint, pointRadius, {
+                    ...lineOptions,
+                    fill: inSlice ? pointColor : 'transparent',
+                }, `${annotationUID}-marker`);
+            }
+            else {
+                const { clientWidth, clientHeight } = getDisplayedCanvasSize(viewport);
+                const gap = Math.max(this.configuration.centerGapRadius ?? 0, 0);
+                const [x, y] = canvasPoint;
+                const segments = [
+                    ['marker-h1', [0, y], [x - gap, y]],
+                    ['marker-h2', [x + gap, y], [clientWidth, y]],
+                    ['marker-v1', [x, 0], [x, y - gap]],
+                    ['marker-v2', [x, y + gap], [x, clientHeight]],
+                ];
+                segments.forEach(([uid, startPoint, endPoint]) => {
+                    const length = Math.hypot(endPoint[0] - startPoint[0], endPoint[1] - startPoint[1]);
+                    const towardsPositive = endPoint[0] >= startPoint[0] && endPoint[1] >= startPoint[1];
+                    if (length < 1 || !towardsPositive) {
+                        return;
+                    }
+                    drawLineSvg(svgDrawingHelper, annotationUID, uid, startPoint, endPoint, lineOptions, `${annotationUID}-${uid}`);
+                });
+            }
+            if (!inSlice && offSliceDisplay === 'projectedWithDistance') {
+                const sign = distanceMm >= 0 ? '+' : '-';
+                const label = `${sign}${Math.abs(distanceMm).toFixed(1)} mm`;
+                drawTextBoxSvg(svgDrawingHelper, annotationUID, 'marker-distance', [label], [canvasPoint[0] + pointRadius + 6, canvasPoint[1] + pointRadius + 6], {
+                    color: pointColor,
+                });
+            }
+            return true;
+        };
+    }
+    setWorldPoint(worldPoint, options = {}) {
+        if (!isFinitePoint3(worldPoint)) {
+            return;
+        }
+        const newPoint = [
+            worldPoint[0],
+            worldPoint[1],
+            worldPoint[2],
+        ];
+        const previousPoint = this._state.worldPoint;
+        const changed = !previousPoint || vec3.distance(previousPoint, newPoint) > POINT_EPSILON;
+        if (options.sourceViewportId !== undefined) {
+            this._state.sourceViewportId = options.sourceViewportId;
+        }
+        if (options.sourceRenderingEngineId !== undefined) {
+            this._state.sourceRenderingEngineId = options.sourceRenderingEngineId;
+        }
+        const frameOfReferenceChanged = options.frameOfReferenceUID !== undefined &&
+            options.frameOfReferenceUID !== this._state.frameOfReferenceUID;
+        if (options.frameOfReferenceUID !== undefined) {
+            this._state.frameOfReferenceUID = options.frameOfReferenceUID;
+        }
+        if (changed) {
+            this._state.worldPoint = newPoint;
+            this._autoInitialized = true;
+        }
+        if (changed || frameOfReferenceChanged) {
+            this._syncAnnotation();
+        }
+        if (changed) {
+            if (!options.suppressEvents) {
+                triggerEvent(eventTarget, Events.WORLD_CROSSHAIR_POINT_CHANGED, this._getEventDetail());
+            }
+        }
+        const shouldJump = options.jump ?? this.configuration.jumpOnSet;
+        if (shouldJump) {
+            this._jumpLinkedViewports({ suppressEvents: true });
+        }
+        if (changed) {
+            this._update3DLines();
+        }
+        this._renderLinkedViewports();
+    }
+    getWorldPoint() {
+        const { worldPoint } = this._state;
+        return worldPoint ? [worldPoint[0], worldPoint[1], worldPoint[2]] : null;
+    }
+    clearWorldPoint(options = {}) {
+        if (!this._state.worldPoint) {
+            return;
+        }
+        this._state.worldPoint = null;
+        this._state.cursorWorldPoint = null;
+        this._syncAnnotation();
+        this._update3DLines();
+        if (!options.suppressEvents) {
+            triggerEvent(eventTarget, Events.WORLD_CROSSHAIR_POINT_CLEARED, this._getEventDetail());
+        }
+        this._renderLinkedViewports();
+    }
+    clearWorldCrosshair(options = {}) {
+        this.clearWorldPoint(options);
+    }
+    jumpLinkedViewportsToWorldPoint(options = {}) {
+        this._jumpLinkedViewports({ ...options, suppressEvents: false });
+    }
+    setVisibility(visible) {
+        if (this._state.visible === visible) {
+            return;
+        }
+        this._state.visible = visible;
+        this._update3DLines();
+        this._renderLinkedViewports();
+    }
+    setLocked(locked) {
+        this._state.locked = locked;
+    }
+    getState() {
+        return {
+            toolGroupId: this.toolGroupId,
+            ...this._state,
+            worldPoint: this.getWorldPoint(),
+            cursorWorldPoint: this._state.cursorWorldPoint
+                ? [...this._state.cursorWorldPoint]
+                : null,
+        };
+    }
+    onSetToolEnabled() {
+        this._syncAnnotation();
+        this._maybeAutoInitialize();
+        this._update3DLines();
+        this._renderLinkedViewports();
+    }
+    onSetToolActive() {
+        this.onSetToolEnabled();
+    }
+    onSetToolPassive() {
+        this.onSetToolEnabled();
+    }
+    onSetToolDisabled() {
+        this._isDragging = false;
+        this._autoInitialized = false;
+        state.isInteractingWithTool = false;
+        if (this._annotation?.annotationUID) {
+            removeAnnotation(this._annotation.annotationUID);
+        }
+        this._annotation = null;
+        this._get3DViewports().forEach((viewport) => removeWorldCrosshairLines3D(viewport, this._getMarkerUIDPrefix()));
+        this._renderLinkedViewports();
+    }
+    getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
+        if (this.isPointNearTool(element, annotation, canvasCoords, proximity, 'mouse')) {
+            return this._state.worldPoint;
+        }
+    }
+    _startDrag(element) {
+        this._isDragging = true;
+        this._activateModify(element);
+    }
+    _maybeAutoInitialize(enabledElement) {
+        if (this._autoInitialized ||
+            this._state.worldPoint ||
+            !this.configuration.autoInitializeOnEnable) {
+            return;
+        }
+        let viewport = enabledElement?.viewport;
+        let renderingEngineId = enabledElement?.renderingEngine?.id;
+        let frameOfReferenceUID = enabledElement?.FrameOfReferenceUID;
+        if (!viewport) {
+            for (const info of this._getViewportsInfo()) {
+                const candidate = getEnabledElementByIds(info.viewportId, info.renderingEngineId);
+                if (candidate && this._isPlanarViewport(candidate.viewport)) {
+                    viewport = candidate.viewport;
+                    renderingEngineId = candidate.renderingEngine?.id;
+                    frameOfReferenceUID = candidate.FrameOfReferenceUID;
+                    break;
+                }
+            }
+        }
+        if (!viewport || !this._isPlanarViewport(viewport)) {
+            return;
+        }
+        let focalPoint;
+        try {
+            ({ focalPoint } = getViewportICamera(viewport));
+        }
+        catch {
+            return;
+        }
+        if (!isFinitePoint3(focalPoint)) {
+            return;
+        }
+        this.setWorldPoint(focalPoint, {
+            sourceViewportId: viewport.id,
+            sourceRenderingEngineId: renderingEngineId,
+            frameOfReferenceUID: frameOfReferenceUID ?? viewport.getFrameOfReferenceUID?.(),
+            jump: false,
+        });
+    }
+    _jumpLinkedViewports(options = {}) {
+        const { worldPoint } = this._state;
+        if (!worldPoint) {
+            return;
+        }
+        const jumpMode = options.jumpMode ?? this.configuration.jumpMode;
+        const previousInteracting = state.isInteractingWithTool;
+        state.isInteractingWithTool = true;
+        try {
+            this._getLinkedViewports().forEach((viewport) => {
+                this._jumpViewportToPoint(viewport, worldPoint, jumpMode);
+            });
+        }
+        finally {
+            state.isInteractingWithTool = previousInteracting;
+        }
+        if (!options.suppressEvents) {
+            triggerEvent(eventTarget, Events.WORLD_CROSSHAIR_JUMPED_TO_POINT, this._getEventDetail());
+        }
+    }
+    _jumpViewportToPoint(viewport, worldPoint, jumpMode) {
+        if (!this._isPlanarViewport(viewport)) {
+            return;
+        }
+        let camera;
+        try {
+            camera = getViewportICamera(viewport);
+        }
+        catch {
+            return;
+        }
+        const { focalPoint, viewPlaneNormal } = camera;
+        if (!focalPoint || !viewPlaneNormal) {
+            return;
+        }
+        const delta = vec3.subtract(vec3.create(), worldPoint, focalPoint);
+        const normalDistance = vec3.dot(delta, viewPlaneNormal);
+        if (jumpMode === 'centered') {
+            if (!navigatePlanarViewportToPoint(viewport, worldPoint)) {
+                return;
+            }
+            viewport.setViewState({
+                anchorWorld: [worldPoint[0], worldPoint[1], worldPoint[2]],
+                anchorCanvas: [0.5, 0.5],
+            });
+            viewport.render();
+            return;
+        }
+        if (Math.abs(normalDistance) < JUMP_EPSILON) {
+            return;
+        }
+        const targetFocalPoint = vec3.scaleAndAdd(vec3.create(), focalPoint, viewPlaneNormal, normalDistance);
+        if (navigatePlanarViewportToPoint(viewport, [
+            targetFocalPoint[0],
+            targetFocalPoint[1],
+            targetFocalPoint[2],
+        ])) {
+            viewport.render();
+        }
+    }
+    _get3DViewports() {
+        const { threeDViewportIds } = this.configuration;
+        if (!threeDViewportIds?.length) {
+            return [];
+        }
+        return threeDViewportIds
+            .map((viewportId) => getEnabledElementByViewportId(viewportId)?.viewport)
+            .filter((viewport) => viewport &&
+            viewport.type === ViewportType.VOLUME_3D_NEXT &&
+            csUtils.isGenericViewport(viewport));
+    }
+    _update3DLines() {
+        const { showIn3D, threeDLineLengthMm, pointColor } = this.configuration;
+        const { worldPoint, visible } = this._state;
+        const uidPrefix = this._getMarkerUIDPrefix();
+        this._get3DViewports().forEach((viewport) => {
+            if (showIn3D && visible && worldPoint) {
+                updateWorldCrosshairLines3D(viewport, worldPoint, {
+                    lineLengthMm: threeDLineLengthMm,
+                    color: parseCssColorToRGB(pointColor),
+                    uidPrefix,
+                });
+            }
+            else {
+                removeWorldCrosshairLines3D(viewport, uidPrefix);
+            }
+        });
+    }
+    _getMarkerUIDPrefix() {
+        return `WorldCrosshair-${this.toolGroupId}`;
+    }
+    _isPlanarViewport(viewport) {
+        return (viewport?.type === ViewportType.PLANAR_NEXT &&
+            csUtils.isGenericViewport(viewport));
+    }
+    _getViewportsInfo() {
+        return getToolGroup(this.toolGroupId)?.viewportsInfo ?? [];
+    }
+    _getLinkedViewports() {
+        const viewports = this._getViewportsInfo()
+            .map(({ viewportId, renderingEngineId }) => getEnabledElementByIds(viewportId, renderingEngineId)?.viewport)
+            .filter((viewport) => viewport && this._isPlanarViewport(viewport));
+        const { linkPolicy, explicitLinkedViewportIds } = this.configuration;
+        const { sourceViewportId, frameOfReferenceUID } = this._state;
+        if (linkPolicy === 'explicit') {
+            return viewports.filter((viewport) => viewport.id === sourceViewportId ||
+                explicitLinkedViewportIds?.includes(viewport.id));
+        }
+        if (linkPolicy === 'frameOfReferenceUID') {
+            if (!frameOfReferenceUID) {
+                return viewports;
+            }
+            return viewports.filter((viewport) => viewport.id === sourceViewportId ||
+                viewport.getFrameOfReferenceUID?.() === frameOfReferenceUID);
+        }
+        return viewports;
+    }
+    _isViewportLinked(viewport) {
+        if (!this._isPlanarViewport(viewport)) {
+            return false;
+        }
+        if (!this._getViewportsInfo().some(({ viewportId }) => viewportId === viewport.id)) {
+            return false;
+        }
+        const { linkPolicy, explicitLinkedViewportIds } = this.configuration;
+        const { sourceViewportId, frameOfReferenceUID } = this._state;
+        if (viewport.id === sourceViewportId) {
+            return true;
+        }
+        if (linkPolicy === 'explicit') {
+            return !!explicitLinkedViewportIds?.includes(viewport.id);
+        }
+        if (linkPolicy === 'frameOfReferenceUID') {
+            if (!frameOfReferenceUID) {
+                return true;
+            }
+            return viewport.getFrameOfReferenceUID?.() === frameOfReferenceUID;
+        }
+        return true;
+    }
+    _renderLinkedViewports() {
+        const viewportIds = this._getLinkedViewports().map((viewport) => viewport.id);
+        if (viewportIds.length) {
+            triggerAnnotationRenderForViewportIds(viewportIds);
+        }
+    }
+    _getMarkerCanvasPosition(viewport) {
+        const { worldPoint, visible } = this._state;
+        const { showIn2D, offSliceDisplay, offSliceToleranceMm } = this.configuration;
+        if (!worldPoint || !visible || !showIn2D) {
+            return null;
+        }
+        if (!this._isPlanarViewport(viewport)) {
+            return null;
+        }
+        if (!this._isViewportLinked(viewport)) {
+            return null;
+        }
+        const plane = getViewportPlane(viewport);
+        if (!plane) {
+            return null;
+        }
+        const distanceMm = distancePointToPlane(worldPoint, plane);
+        const toleranceMm = this._getEffectiveOffSliceTolerance(viewport, plane, offSliceToleranceMm);
+        if (Math.abs(distanceMm) > toleranceMm && offSliceDisplay === 'hide') {
+            return null;
+        }
+        const projected = projectPointToPlane(worldPoint, plane);
+        const canvasPoint = viewport.worldToCanvas(projected);
+        if (!canvasPoint || !canvasPoint.every((c) => Number.isFinite(c))) {
+            return null;
+        }
+        return canvasPoint;
+    }
+    _resolveInteractionWorldPoint(viewport, world) {
+        if (!this.configuration.snapToSlabIntensity) {
+            return world;
+        }
+        return pickIntensityPointInSlab(viewport, world) ?? world;
+    }
+    _getSourceSlabThicknessMm(viewport) {
+        if (!csUtils.viewportSupportsDisplaySetPresentation(viewport)) {
+            return 0;
+        }
+        const dataId = viewport.getSourceDataId();
+        if (!dataId) {
+            return 0;
+        }
+        const presentation = viewport.getDisplaySetPresentation(dataId);
+        const slabThickness = presentation?.slabThickness;
+        return Number.isFinite(slabThickness) && slabThickness > 0
+            ? slabThickness
+            : 0;
+    }
+    _getEffectiveOffSliceTolerance(viewport, plane, baseToleranceMm) {
+        const slabThickness = this._getSourceSlabThicknessMm(viewport);
+        const toleranceMm = Math.max(baseToleranceMm, slabThickness > 0 ? slabThickness / 2 + 1e-2 : 0);
+        let spacing;
+        try {
+            spacing = viewport.getImageData?.()
+                ?.spacing;
+        }
+        catch {
+            spacing = undefined;
+        }
+        if (!spacing || spacing.length !== 3) {
+            return toleranceMm;
+        }
+        const [nx, ny, nz] = plane.normal;
+        const spacingAlongNormal = Math.abs(nx) * spacing[0] +
+            Math.abs(ny) * spacing[1] +
+            Math.abs(nz) * spacing[2];
+        if (!Number.isFinite(spacingAlongNormal) || spacingAlongNormal <= 0) {
+            return toleranceMm;
+        }
+        return Math.max(toleranceMm, spacingAlongNormal / 2 + 1e-2);
+    }
+    _syncAnnotation() {
+        const { worldPoint, frameOfReferenceUID } = this._state;
+        if (!worldPoint) {
+            if (this._annotation?.annotationUID) {
+                removeAnnotation(this._annotation.annotationUID);
+            }
+            this._annotation = null;
+            return;
+        }
+        if (this._annotation &&
+            frameOfReferenceUID &&
+            this._annotation.metadata.FrameOfReferenceUID !== frameOfReferenceUID) {
+            removeAnnotation(this._annotation.annotationUID);
+            this._annotation = null;
+        }
+        if (this._annotation) {
+            this._annotation.data.handles.points = [
+                [worldPoint[0], worldPoint[1], worldPoint[2]],
+            ];
+            this._annotation.invalidated = true;
+            return;
+        }
+        if (!frameOfReferenceUID) {
+            return;
+        }
+        const annotation = {
+            highlighted: false,
+            invalidated: true,
+            metadata: {
+                toolName: this.getToolName(),
+                FrameOfReferenceUID: frameOfReferenceUID,
+            },
+            data: {
+                handles: {
+                    points: [[worldPoint[0], worldPoint[1], worldPoint[2]]],
+                },
+            },
+        };
+        addAnnotation(annotation, frameOfReferenceUID);
+        this._annotation = annotation;
+    }
+    _getAnnotationOrDetached() {
+        if (this._annotation) {
+            return this._annotation;
+        }
+        return {
+            annotationUID: csUtils.uuidv4(),
+            highlighted: false,
+            invalidated: false,
+            metadata: {
+                toolName: this.getToolName(),
+            },
+            data: {
+                handles: { points: [] },
+            },
+        };
+    }
+    _getEventDetail() {
+        const { sourceViewportId, sourceRenderingEngineId, frameOfReferenceUID } = this._state;
+        return {
+            toolGroupId: this.toolGroupId,
+            worldPoint: this.getWorldPoint(),
+            sourceViewportId,
+            sourceRenderingEngineId,
+            frameOfReferenceUID,
+        };
+    }
+}
+WorldCrosshairTool.toolLabel = 'Reference Point';
+WorldCrosshairTool.toolName = 'WorldCrosshair';
+export default WorldCrosshairTool;