@cornerstonejs/tools 5.4.17 → 5.5.0

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

@@ -42,10 +42,8 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
     private _mouseDownCallback;
     private _mouseMoveCallback;
     editHandle(worldPos: Types.Point3, element: any, annotation: LivewireContourAnnotation, handleIndex: number): void;
-    private _dragCallback;
+    protected _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     cancel: (element: HTMLDivElement) => string;
-    private _activateModify;
-    private _deactivateModify;
     private _activateDraw;
     private _deactivateDraw;
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;

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

@@ -268,24 +268,6 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             this.scissors = null;
             return annotation.annotationUID;
         };
-        this._activateModify = (element) => {
-            state.isInteractingWithTool = true;
-            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._deactivateModify = (element) => {
-            state.isInteractingWithTool = false;
-            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);
-        };
         this._activateDraw = (element) => {
             state.isInteractingWithTool = true;
             element.addEventListener(Events.MOUSE_MOVE, this._mouseMoveCallback);

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

@@ -52,13 +52,11 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     private _keyDownCallback;
     private _mouseMoveCallback;
     private _mouseDownCallback;
-    private _dragCallback;
+    protected _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     cancel(element: HTMLDivElement): string;
     triggerAnnotationCompleted: (annotation: SplineROIAnnotation, contourHoleProcessingEnabled: boolean) => void;
     triggerAnnotationModified: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType?: ChangeTypes) => void;
     triggerChangeEvent: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType: ChangeTypes, contourHoleProcessingEnabled: any) => void;
-    private _activateModify;
-    private _deactivateModify;
     private _activateDraw;
     private _deactivateDraw;
     protected isContourSegmentationTool(): boolean;

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

@@ -336,24 +336,6 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 this.triggerAnnotationModified(annotation, enabledElement, changeType);
             }
         };
-        this._activateModify = (element) => {
-            state.isInteractingWithTool = true;
-            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._deactivateModify = (element) => {
-            state.isInteractingWithTool = false;
-            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);
-        };
         this._activateDraw = (element) => {
             state.isInteractingWithTool = true;
             element.addEventListener(Events.KEY_DOWN, this._keyDownCallback);

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

@@ -28,6 +28,10 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     abstract handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: Annotation, handle: ToolHandle, interactionType: InteractionTypes): void;
     abstract toolSelectedCallback(evt: EventTypes.InteractionEventType, annotation: Annotation, interactionType: InteractionTypes, canvasCoords?: Types.Point2): void;
     abstract isPointNearTool(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number, interactionType: string): boolean;
+    protected _dragCallback?: (evt: any) => void;
+    protected _endCallback?: (evt: any) => void;
+    protected _activateModify: (element: HTMLDivElement) => void;
+    protected _deactivateModify: (element: HTMLDivElement) => void;
     mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredAnnotations?: Annotations) => boolean;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
     getLinkedTextBoxStyle(specifications: StyleSpecifier, annotation?: Annotation): Record<string, unknown>;

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

@@ -5,6 +5,8 @@ import { isAnnotationLocked } from '../../stateManagement/annotation/annotationL
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility.js';
 import { addAnnotation, removeAnnotation, getAnnotation, } from '../../stateManagement/annotation/annotationState.js';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state.js';
+import { state } from '../../store/state.js';
+import { Events } from '../../enums/index.js';
 import { drawLinkedTextBox } from '../../drawingSvg/index.js';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing/index.js';
 import ChangeTypes from '../../enums/ChangeTypes.js';
@@ -24,6 +26,24 @@ class AnnotationTool extends AnnotationDisplayTool {
     }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
+        this._activateModify = (element) => {
+            state.isInteractingWithTool = true;
+            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._deactivateModify = (element) => {
+            state.isInteractingWithTool = false;
+            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);
+        };
         this.mouseMoveCallback = (evt, filteredAnnotations) => {
             if (!filteredAnnotations) {
                 return false;

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

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

package/dist/esm/tools/index.js

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

package/dist/esm/tools/worldCrosshair/WorldCrosshairLines3D.d.ts

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+export type WorldCrosshairLines3DOptions = {
+    lineLengthMm: number;
+    color: [number, number, number];
+    uidPrefix: string;
+};
+export declare function updateWorldCrosshairLines3D(viewport: Types.IViewport, worldPoint: Types.Point3, options: WorldCrosshairLines3DOptions): void;
+export declare function removeWorldCrosshairLines3D(viewport: Types.IViewport, uidPrefix: string): void;

package/dist/esm/tools/worldCrosshair/WorldCrosshairLines3D.js

@@ -0,0 +1,81 @@
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor.js';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper.js';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData.js';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points.js';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray.js';
+const linesByKey = new Map();
+function getKey(viewport, uidPrefix) {
+    return `${viewport.id}:${uidPrefix}`;
+}
+function setCrosshairLinePoints(polyData, worldPoint, halfLength) {
+    const [x, y, z] = worldPoint;
+    const points = vtkPoints.newInstance();
+    points.setNumberOfPoints(6);
+    points.setPoint(0, x - halfLength, y, z);
+    points.setPoint(1, x + halfLength, y, z);
+    points.setPoint(2, x, y - halfLength, z);
+    points.setPoint(3, x, y + halfLength, z);
+    points.setPoint(4, x, y, z - halfLength);
+    points.setPoint(5, x, y, z + halfLength);
+    const lines = vtkCellArray.newInstance({
+        values: [2, 0, 1, 2, 2, 3, 2, 4, 5],
+    });
+    polyData.setPoints(points);
+    polyData.setLines(lines);
+    polyData.modified();
+}
+function getViewportRenderer(viewport) {
+    return typeof viewport?.getRenderer === 'function'
+        ? viewport.getRenderer()
+        : undefined;
+}
+export function updateWorldCrosshairLines3D(viewport, worldPoint, options) {
+    const renderer = getViewportRenderer(viewport);
+    if (!renderer || !worldPoint) {
+        return;
+    }
+    const { lineLengthMm, color, uidPrefix } = options;
+    const halfLength = Math.max(lineLengthMm / 2, 1);
+    const key = getKey(viewport, uidPrefix);
+    let entry = linesByKey.get(key);
+    const isAttached = entry && !!renderer.getActors?.().includes(entry.actor);
+    if (!entry || !isAttached) {
+        if (entry) {
+            renderer.removeActor(entry.actor);
+        }
+        const polyData = vtkPolyData.newInstance();
+        setCrosshairLinePoints(polyData, worldPoint, halfLength);
+        const mapper = vtkMapper.newInstance();
+        mapper.setInputData(polyData);
+        const actor = vtkActor.newInstance();
+        actor.setMapper(mapper);
+        actor.getProperty().setColor(...color);
+        actor.getProperty().setLineWidth(1.5);
+        actor.getProperty().setInterpolationToFlat();
+        actor.getProperty().setAmbient(1.0);
+        actor.getProperty().setDiffuse(0.0);
+        actor.getProperty().setSpecular(0.0);
+        renderer.addActor(actor);
+        renderer.resetCameraClippingRange?.();
+        entry = { actor, polyData };
+        linesByKey.set(key, entry);
+    }
+    else {
+        setCrosshairLinePoints(entry.polyData, worldPoint, halfLength);
+    }
+    viewport.render();
+}
+export function removeWorldCrosshairLines3D(viewport, uidPrefix) {
+    const key = getKey(viewport, uidPrefix);
+    const entry = linesByKey.get(key);
+    linesByKey.delete(key);
+    if (!entry) {
+        return;
+    }
+    const renderer = getViewportRenderer(viewport);
+    if (!renderer) {
+        return;
+    }
+    renderer.removeActor(entry.actor);
+    viewport.render();
+}

package/dist/esm/utilities/genericViewportToolHelpers.d.ts

@@ -1,6 +1,7 @@
 import { type Types } from '@cornerstonejs/core';
 export declare function getSlabThicknessOrDefault(viewport: Types.IViewport): number;
 export declare function jumpToFocalPoint(viewport: Types.IViewport, cameraFocalPoint: Types.Point3): void;
+export declare function navigatePlanarViewportToPoint(viewport: Types.IViewport, worldPoint: Types.Point3): boolean;
 export interface NativeSourceProperties {
     properties: Record<string, unknown>;
     rotation?: number;

package/dist/esm/utilities/genericViewportToolHelpers.js

@@ -12,6 +12,37 @@ export function jumpToFocalPoint(viewport, cameraFocalPoint) {
         viewport.setViewReference({ cameraFocalPoint });
     }
 }
+export function navigatePlanarViewportToPoint(viewport, worldPoint) {
+    if (!csUtils.isGenericViewport(viewport)) {
+        return false;
+    }
+    const isStackContent = viewport.getCurrentMode?.() === 'stack';
+    if (isStackContent) {
+        const stackViewport = viewport;
+        if (typeof stackViewport.getImageIds !== 'function' ||
+            typeof stackViewport.getCurrentImageIdIndex !== 'function') {
+            return false;
+        }
+        let imageIndex = null;
+        try {
+            imageIndex = csUtils.getClosestStackImageIndexForPoint(worldPoint, stackViewport);
+        }
+        catch {
+            return false;
+        }
+        if (imageIndex === null || imageIndex < 0) {
+            return false;
+        }
+        viewport.setViewReference({
+            sliceIndex: imageIndex,
+        });
+        return true;
+    }
+    viewport.setViewReference({
+        cameraFocalPoint: [worldPoint[0], worldPoint[1], worldPoint[2]],
+    });
+    return true;
+}
 export function getNativeSourceProperties(viewport) {
     if (!csUtils.viewportSupportsDisplaySetPresentation(viewport)) {
         return { properties: {} };

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

@@ -18,6 +18,7 @@ import * as segmentation from './segmentation/index.js';
 import * as drawing from './drawing/index.js';
 import * as math from './math/index.js';
 import * as planar from './planar/index.js';
+import * as spatial from './spatial/index.js';
 import * as viewportFilters from './viewportFilters/index.js';
 import * as orientation from './orientation/index.js';
 import * as cine from './cine/index.js';
@@ -44,4 +45,5 @@ import { safeStructuredClone } from './safeStructuredClone.js';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume.js';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction.js';
 import { jumpToFocalPoint } from './genericViewportToolHelpers.js';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, };
+import pickIntensityPointInSlab, { getSlabIntensityPickContext } from './pickIntensityPointInSlab.js';
+export { math, planar, spatial, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, pickIntensityPointInSlab, getSlabIntensityPickContext, };

package/dist/esm/utilities/index.js

@@ -18,6 +18,7 @@ import * as segmentation from './segmentation/index.js';
 import * as drawing from './drawing/index.js';
 import * as math from './math/index.js';
 import * as planar from './planar/index.js';
+import * as spatial from './spatial/index.js';
 import * as viewportFilters from './viewportFilters/index.js';
 import * as orientation from './orientation/index.js';
 import * as cine from './cine/index.js';
@@ -44,4 +45,5 @@ import { safeStructuredClone } from './safeStructuredClone.js';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume.js';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction.js';
 import { jumpToFocalPoint } from './genericViewportToolHelpers.js';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, };
+import pickIntensityPointInSlab, { getSlabIntensityPickContext, } from './pickIntensityPointInSlab.js';
+export { math, planar, spatial, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, pickIntensityPointInSlab, getSlabIntensityPickContext, };

package/dist/esm/utilities/pickIntensityPointInSlab.d.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+export type SlabIntensityPickMode = 'max' | 'min';
+export declare function getSlabIntensityPickContext(viewport: Types.IViewport): {
+    mode: SlabIntensityPickMode;
+    slabThicknessMm: number;
+} | null;
+export default function pickIntensityPointInSlab(viewport: Types.IViewport, worldPoint: Types.Point3): Types.Point3 | null;

package/dist/esm/utilities/pickIntensityPointInSlab.js

@@ -0,0 +1,106 @@
+import { vec3 } from 'gl-matrix';
+import { cache, Enums, utilities as csUtils, CONSTANTS, } from '@cornerstonejs/core';
+import { getViewportPlane } from './spatial/index.js';
+const { RENDERING_DEFAULTS } = CONSTANTS;
+const STEP_SPACING_FRACTION = 0.25;
+const MAX_SAMPLES = 2001;
+export function getSlabIntensityPickContext(viewport) {
+    if (!csUtils.isGenericViewport(viewport)) {
+        return null;
+    }
+    try {
+        if (viewport.getCurrentMode?.() !== 'volume') {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    if (!csUtils.viewportSupportsDisplaySetPresentation(viewport)) {
+        return null;
+    }
+    const dataId = viewport.getSourceDataId();
+    if (!dataId) {
+        return null;
+    }
+    const presentation = viewport.getDisplaySetPresentation(dataId);
+    const { blendMode, slabThickness } = presentation ?? {};
+    let mode;
+    if (blendMode === Enums.BlendModes.MAXIMUM_INTENSITY_BLEND) {
+        mode = 'max';
+    }
+    else if (blendMode === Enums.BlendModes.MINIMUM_INTENSITY_BLEND) {
+        mode = 'min';
+    }
+    else {
+        return null;
+    }
+    if (!Number.isFinite(slabThickness) ||
+        slabThickness <= RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS) {
+        return null;
+    }
+    return { mode, slabThicknessMm: slabThickness };
+}
+export default function pickIntensityPointInSlab(viewport, worldPoint) {
+    const context = getSlabIntensityPickContext(viewport);
+    if (!context || !worldPoint) {
+        return null;
+    }
+    const volumeId = viewport.getVolumeId?.();
+    const volume = volumeId ? cache.getVolume(volumeId) : undefined;
+    if (!volume?.voxelManager ||
+        !volume.dimensions ||
+        !volume.spacing ||
+        !volume.direction ||
+        !volume.origin) {
+        return null;
+    }
+    const plane = getViewportPlane(viewport);
+    if (!plane) {
+        return null;
+    }
+    const normal = plane.normal;
+    const spacingAlongNormal = Math.abs(normal[0]) * volume.spacing[0] +
+        Math.abs(normal[1]) * volume.spacing[1] +
+        Math.abs(normal[2]) * volume.spacing[2];
+    if (!Number.isFinite(spacingAlongNormal) || spacingAlongNormal <= 0) {
+        return null;
+    }
+    const halfRange = context.slabThicknessMm / 2;
+    let step = spacingAlongNormal * STEP_SPACING_FRACTION;
+    const stepsPerSide = Math.min(Math.ceil(halfRange / step), (MAX_SAMPLES - 1) / 2);
+    step = halfRange / stepsPerSide;
+    const wantMax = context.mode === 'max';
+    let bestValue = NaN;
+    let bestOffset = 0;
+    const samplePoint = vec3.create();
+    const sampleAt = (offset) => {
+        vec3.scaleAndAdd(samplePoint, worldPoint, normal, offset);
+        const value = csUtils.VoxelManager.sampleAtWorld(volume, [
+            samplePoint[0],
+            samplePoint[1],
+            samplePoint[2],
+        ]);
+        if (!Number.isFinite(value)) {
+            return;
+        }
+        if (Number.isNaN(bestValue) ||
+            (wantMax ? value > bestValue : value < bestValue)) {
+            bestValue = value;
+            bestOffset = offset;
+        }
+    };
+    sampleAt(0);
+    for (let i = 1; i <= stepsPerSide; i++) {
+        sampleAt(i * step);
+        sampleAt(-i * step);
+    }
+    if (Number.isNaN(bestValue)) {
+        return null;
+    }
+    return [
+        worldPoint[0] + normal[0] * bestOffset,
+        worldPoint[1] + normal[1] * bestOffset,
+        worldPoint[2] + normal[2] * bestOffset,
+    ];
+}

package/dist/esm/utilities/spatial/areViewportsSpatiallyLinked.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { SpatialLinkOptions } from './types.js';
+export default function areViewportsSpatiallyLinked(source: Types.IViewport, target: Types.IViewport, options: SpatialLinkOptions): boolean;

package/dist/esm/utilities/spatial/areViewportsSpatiallyLinked.js

@@ -0,0 +1,48 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager/index.js';
+function getFrameOfReferenceUID(viewport) {
+    return viewport.getFrameOfReferenceUID?.();
+}
+function hasRegistrationTransform(sourceFrameOfReferenceUID, targetFrameOfReferenceUID, options) {
+    const { registrationTransforms } = options;
+    if (!registrationTransforms?.size) {
+        return false;
+    }
+    return (registrationTransforms.has(`${sourceFrameOfReferenceUID}:${targetFrameOfReferenceUID}`) ||
+        registrationTransforms.has(`${targetFrameOfReferenceUID}:${sourceFrameOfReferenceUID}`));
+}
+export default function areViewportsSpatiallyLinked(source, target, options) {
+    if (!source || !target || !options?.policy) {
+        return false;
+    }
+    switch (options.policy) {
+        case 'frameOfReferenceUID': {
+            const sourceFrameOfReferenceUID = getFrameOfReferenceUID(source);
+            const targetFrameOfReferenceUID = getFrameOfReferenceUID(target);
+            if (!sourceFrameOfReferenceUID || !targetFrameOfReferenceUID) {
+                return false;
+            }
+            if (sourceFrameOfReferenceUID === targetFrameOfReferenceUID) {
+                return true;
+            }
+            return hasRegistrationTransform(sourceFrameOfReferenceUID, targetFrameOfReferenceUID, options);
+        }
+        case 'explicit': {
+            const { explicitLinks } = options;
+            if (!explicitLinks?.length) {
+                return false;
+            }
+            return explicitLinks.some((link) => (link.sourceViewportId === source.id &&
+                link.targetViewportId === target.id) ||
+                (link.sourceViewportId === target.id &&
+                    link.targetViewportId === source.id));
+        }
+        case 'toolGroup': {
+            const sourceToolGroup = getToolGroupForViewport(source.id, source.renderingEngineId);
+            const targetToolGroup = getToolGroupForViewport(target.id, target.renderingEngineId);
+            return (!!sourceToolGroup && !!targetToolGroup &&
+                sourceToolGroup.id === targetToolGroup.id);
+        }
+        default:
+            return false;
+    }
+}

package/dist/esm/utilities/spatial/clipWorldLineToViewportCanvas.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { WorldLine } from './types.js';
+export default function clipWorldLineToViewportCanvas(line: WorldLine, viewport: Types.IVolumeViewport | Types.IViewport): [Types.Point2, Types.Point2] | null;

package/dist/esm/utilities/spatial/clipWorldLineToViewportCanvas.js

@@ -0,0 +1,58 @@
+import { vec3 } from 'gl-matrix';
+import liangBarksyClip from '../math/vec2/liangBarksyClip.js';
+import getDisplayedCanvasSize from './getDisplayedCanvasSize.js';
+const MIN_SEGMENT_LENGTH = 1e-3;
+export default function clipWorldLineToViewportCanvas(line, viewport) {
+    if (!line || !viewport) {
+        return null;
+    }
+    const { clientWidth, clientHeight } = getDisplayedCanvasSize(viewport);
+    if (!clientWidth || !clientHeight) {
+        return null;
+    }
+    const direction = vec3.normalize(vec3.create(), line.direction);
+    if (vec3.length(direction) < 1e-10) {
+        return null;
+    }
+    const centerWorld = viewport.canvasToWorld([
+        clientWidth / 2,
+        clientHeight / 2,
+    ]);
+    const toCenter = vec3.subtract(vec3.create(), centerWorld, line.point);
+    const projectedLength = vec3.dot(toCenter, direction);
+    const anchor = vec3.scaleAndAdd(vec3.create(), line.point, direction, projectedLength);
+    const cornerWorld = viewport.canvasToWorld([0, 0]);
+    const halfDiagonalWorld = vec3.distance(centerWorld, cornerWorld);
+    const halfLength = Math.max(halfDiagonalWorld * 2, 1);
+    const startWorld = vec3.scaleAndAdd(vec3.create(), anchor, direction, -halfLength);
+    const endWorld = vec3.scaleAndAdd(vec3.create(), anchor, direction, halfLength);
+    const startCanvas = viewport.worldToCanvas([
+        startWorld[0],
+        startWorld[1],
+        startWorld[2],
+    ]);
+    const endCanvas = viewport.worldToCanvas([
+        endWorld[0],
+        endWorld[1],
+        endWorld[2],
+    ]);
+    if (![...startCanvas, ...endCanvas].every((component) => Number.isFinite(component))) {
+        return null;
+    }
+    const clippedStart = [startCanvas[0], startCanvas[1]];
+    const clippedEnd = [endCanvas[0], endCanvas[1]];
+    const inside = liangBarksyClip(clippedStart, clippedEnd, [
+        0,
+        0,
+        clientWidth,
+        clientHeight,
+    ]);
+    if (inside !== 1) {
+        return null;
+    }
+    const segmentLength = Math.hypot(clippedEnd[0] - clippedStart[0], clippedEnd[1] - clippedStart[1]);
+    if (segmentLength < MIN_SEGMENT_LENGTH) {
+        return null;
+    }
+    return [clippedStart, clippedEnd];
+}

package/dist/esm/utilities/spatial/distancePointToPlane.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Plane } from './types.js';
+export default function distancePointToPlane(point: Types.Point3, plane: Plane): number;

package/dist/esm/utilities/spatial/distancePointToPlane.js

@@ -0,0 +1,6 @@
+import { vec3 } from 'gl-matrix';
+export default function distancePointToPlane(point, plane) {
+    const normal = vec3.normalize(vec3.create(), plane.normal);
+    const toPoint = vec3.subtract(vec3.create(), point, plane.point);
+    return vec3.dot(toPoint, normal);
+}

package/dist/esm/utilities/spatial/getDisplayedCanvasSize.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getDisplayedCanvasSize(viewport: Types.IViewport): {
+    clientWidth: number;
+    clientHeight: number;
+};

package/dist/esm/utilities/spatial/getDisplayedCanvasSize.js

@@ -0,0 +1,12 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+export default function getDisplayedCanvasSize(viewport) {
+    if (csUtils.isGenericViewport(viewport)) {
+        const { element } = viewport;
+        return {
+            clientWidth: element?.clientWidth ?? 0,
+            clientHeight: element?.clientHeight ?? 0,
+        };
+    }
+    const { clientWidth = 0, clientHeight = 0 } = viewport.canvas ?? {};
+    return { clientWidth, clientHeight };
+}

package/dist/esm/utilities/spatial/getViewportPlane.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Plane } from './types.js';
+export default function getViewportPlane(viewport: Types.IViewport): Plane | null;