@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

package/dist/esm/tools/segmentation/utils/shouldUseLazyLabelmapEditing.d.ts

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+export declare function isCPUViewport(viewport?: Types.IViewport): boolean;
+export declare function shouldUseLazyLabelmapEditing(viewport?: Types.IViewport): boolean;

package/dist/esm/tools/segmentation/utils/shouldUseLazyLabelmapEditing.js

@@ -0,0 +1,42 @@
+import { ActorRenderMode, getShouldUseCPURendering, } from '@cornerstonejs/core';
+import { getConfig } from '../../../config';
+const CPU_RENDER_MODES = new Set([
+    ActorRenderMode.CPU_IMAGE,
+    ActorRenderMode.CPU_VOLUME,
+]);
+function getDefaultActor(viewport) {
+    try {
+        return viewport.getDefaultActor?.();
+    }
+    catch {
+        return;
+    }
+}
+export function isCPUViewport(viewport) {
+    if (!viewport) {
+        return getShouldUseCPURendering();
+    }
+    const cpuViewport = viewport;
+    if (cpuViewport.useCPURendering === true) {
+        return true;
+    }
+    if (cpuViewport._cpuFallbackEnabledElement) {
+        return true;
+    }
+    const defaultActor = getDefaultActor(viewport);
+    const renderMode = defaultActor?.actorMapper?.renderMode;
+    if (renderMode && CPU_RENDER_MODES.has(renderMode)) {
+        return true;
+    }
+    const actorClassName = typeof defaultActor?.actor?.getClassName === 'function'
+        ? defaultActor.actor.getClassName()
+        : undefined;
+    if (actorClassName === 'CanvasActor') {
+        return true;
+    }
+    return getShouldUseCPURendering();
+}
+export function shouldUseLazyLabelmapEditing(viewport) {
+    return (getConfig().segmentation?.overwriteMode !== undefined ||
+        isCPUViewport(viewport));
+}

package/dist/esm/types/ISynchronizerEventHandler.d.ts

@@ -1,5 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { Synchronizer } from '../store';
+import type { SynchronizerOptions } from '../store/SynchronizerManager/Synchronizer';
 export default interface ISynchronizerEventHandler {
-    (synchronizer: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, sourceEvent: any, options?: unknown): Promise<void> | void;
+    (synchronizer: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, sourceEvent: Event, options?: SynchronizerOptions): Promise<void> | void;
 }

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -2,9 +2,14 @@ import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationDataStack, LabelmapSegmentationDataVolume } from './LabelmapTypes';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { LabelmapMemo } from '../utilities/segmentation/createLabelmapMemo';
+import type { SegmentLabelmapBindingState } from './LabelmapTypes';
 type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
+    labelValue?: number;
+    labelmapId?: string;
+    overwriteSegmentIndices?: number[];
+    crossLayerEraseBindings?: SegmentLabelmapBindingState[];
     previewColor?: [number, number, number, number];
     previewSegmentIndex?: number;
     segmentsLocked: number[];

package/dist/esm/types/LabelmapTypes.d.ts

@@ -14,16 +14,39 @@ export type InactiveLabelmapStyle = {
     outlineOpacityInactive?: number;
 };
 export type LabelmapStyle = BaseLabelmapStyle & InactiveLabelmapStyle;
-export type LabelmapSegmentationDataVolume = {
-    volumeId: string;
+export type LabelmapLayerType = 'volume' | 'stack';
+export type LabelmapLayer = {
+    labelmapId: string;
+    type: LabelmapLayerType;
+    volumeId?: string;
+    geometryVolumeId?: string;
     referencedVolumeId?: string;
+    referencedImageIds?: string[];
+    imageIds?: string[];
+    labelToSegmentIndex?: {
+        [labelValue: number]: number;
+    };
 };
-export type LabelmapSegmentationDataStack = {
-    imageIds: string[];
+export type SegmentLabelmapBindingState = {
+    labelmapId: string;
+    labelValue: number;
 };
-export type LabelmapSegmentationData = LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack | {
+export type LabelmapSegmentationDataShared = {
+    referencedImageIds?: string[];
+    labelmaps?: {
+        [labelmapId: string]: LabelmapLayer;
+    };
+    segmentBindings?: {
+        [segmentIndex: number]: SegmentLabelmapBindingState;
+    };
+    primaryLabelmapId?: string;
+    sourceRepresentationName?: string;
+};
+export type LabelmapSegmentationDataVolume = LabelmapSegmentationDataShared & {
     volumeId?: string;
     referencedVolumeId?: string;
-    referencedImageIds?: string[];
+};
+export type LabelmapSegmentationDataStack = LabelmapSegmentationDataShared & {
     imageIds?: string[];
 };
+export type LabelmapSegmentationData = LabelmapSegmentationDataShared & LabelmapSegmentationDataVolume & LabelmapSegmentationDataStack;

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -23,9 +23,11 @@ export type Segment = {
 export type Segmentation = {
     segmentationId: string;
     label: string;
+    fallbackLabel?: string;
     segments: {
         [segmentIndex: number]: Segment;
     };
+    segmentOrder?: number[];
     representationData: RepresentationsData;
     cachedStats: {
         [key: string]: unknown;
@@ -36,6 +38,7 @@ export type LabelmapRenderingConfig = {
     ofun: vtkPiecewiseFunction;
     colorLUTIndex: number;
     blendMode?: coreEnums.BlendModes;
+    useSliceRendering?: boolean;
 };
 export type ContourRenderingConfig = {};
 export type SurfaceRenderingConfig = {};
@@ -79,7 +82,9 @@ export type SegmentationPublicInput = {
         segments?: {
             [segmentIndex: number]: Partial<Segment>;
         };
+        segmentOrder?: number[];
         label?: string;
+        fallbackLabel?: string;
         cachedStats?: {
             [key: string]: unknown;
         };
@@ -91,6 +96,7 @@ export type RepresentationPublicInput = {
     config?: {
         colorLUTOrIndex?: Types.ColorLUT | number;
         blendMode?: coreEnums.BlendModes;
+        useSliceRendering?: boolean;
     };
 };
 export {};

package/dist/esm/utilities/calibrateImageSpacing.js

@@ -1,4 +1,5 @@
 import { utilities, Enums } from '@cornerstonejs/core';
+import { viewportSupportsStackCalibration, viewportSupportsStackCompatibility, } from './viewportCapabilities';
 const { calibratedPixelSpacingMetadataProvider } = utilities;
 export default function calibrateImageSpacing(imageId, renderingEngine, calibrationOrScale) {
     if (typeof calibrationOrScale === 'number') {
@@ -8,11 +9,25 @@ export default function calibrateImageSpacing(imageId, renderingEngine, calibrat
         };
     }
     calibratedPixelSpacingMetadataProvider.add(imageId, calibrationOrScale);
-    const viewports = renderingEngine.getStackViewports();
+    const viewports = renderingEngine.getViewports().filter((viewport) => {
+        return (viewportSupportsStackCalibration(viewport) ||
+            viewportSupportsStackCompatibility(viewport));
+    });
     viewports.forEach((viewport) => {
         const imageIds = viewport.getImageIds();
         if (imageIds.includes(imageId)) {
-            viewport.calibrateSpacing(imageId);
+            if (viewportSupportsStackCalibration(viewport)) {
+                viewport.calibrateSpacing(imageId);
+                return;
+            }
+            const currentImageIdIndex = viewport.getCurrentImageIdIndex();
+            void Promise.resolve(viewport.setStack(imageIds, currentImageIdIndex))
+                .then(() => {
+                viewport.render();
+            })
+                .catch((error) => {
+                console.warn('calibrateImageSpacing: failed to refresh stack-compatible viewport', error);
+            });
         }
     });
 }

package/dist/esm/utilities/contours/AnnotationToPointData.js

@@ -8,7 +8,6 @@ function validateAnnotation(annotation) {
     }
 }
 class AnnotationToPointData {
-    static { this.TOOL_NAMES = {}; }
     constructor() {
     }
     static convert(annotation, segment, metadataProvider) {
@@ -36,5 +35,6 @@ class AnnotationToPointData {
         AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
     }
 }
+AnnotationToPointData.TOOL_NAMES = {};
 AnnotationToPointData.register(RectangleROIStartEndThreshold);
 export default AnnotationToPointData;

package/dist/esm/utilities/draw3D/addLine3DBetweenPoints.d.ts

@@ -0,0 +1,7 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import type { Types } from '@cornerstonejs/core';
+export declare function addLine3DBetweenPoints(viewport: Types.IVolumeViewport, point1: Types.Point3, point2: Types.Point3, color?: [number, number, number], uid?: string, showHandles?: boolean): {
+    actor: vtkActor | null;
+    source: vtkPolyData | null;
+};

package/dist/esm/utilities/draw3D/addLine3DBetweenPoints.js

@@ -0,0 +1,34 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+export function addLine3DBetweenPoints(viewport, point1, point2, color = [0.7, 0.7, 0.7], uid = '', showHandles = true) {
+    if (point1[0] === point2[0] &&
+        point1[1] === point2[1] &&
+        point1[2] === point2[2]) {
+        return { actor: null, source: null };
+    }
+    const points = vtkPoints.newInstance();
+    points.setNumberOfPoints(2);
+    points.setPoint(0, point1[0], point1[1], point1[2]);
+    points.setPoint(1, point2[0], point2[1], point2[2]);
+    const lines = vtkCellArray.newInstance({ values: [2, 0, 1] });
+    const polyData = vtkPolyData.newInstance();
+    polyData.setPoints(points);
+    polyData.setLines(lines);
+    const mapper = vtkMapper.newInstance();
+    mapper.setInputData(polyData);
+    const actor = vtkActor.newInstance();
+    actor.setMapper(mapper);
+    actor.getProperty().setColor(...color);
+    actor.getProperty().setLineWidth(0.5);
+    actor.getProperty().setOpacity(1.0);
+    actor.getProperty().setInterpolationToFlat();
+    actor.getProperty().setAmbient(1.0);
+    actor.getProperty().setDiffuse(0.0);
+    actor.getProperty().setSpecular(0.0);
+    actor.setVisibility(showHandles);
+    viewport.addActor({ actor, uid });
+    return { actor, source: polyData };
+}

package/dist/esm/utilities/draw3D/calculateAdaptiveSphereRadius.d.ts

@@ -0,0 +1,6 @@
+export declare function calculateAdaptiveSphereRadius(diagonal: number, config: {
+    sphereRadius?: number;
+    sphereRadiusScale?: number;
+    minSphereRadius?: number;
+    maxSphereRadius?: number;
+}): number;

package/dist/esm/utilities/draw3D/calculateAdaptiveSphereRadius.js

@@ -0,0 +1,7 @@
+export function calculateAdaptiveSphereRadius(diagonal, config) {
+    const scaleFactor = config.sphereRadiusScale || 0.01;
+    const adaptiveRadius = diagonal * scaleFactor;
+    const minRadius = config.minSphereRadius || 2;
+    const maxRadius = config.maxSphereRadius || 50;
+    return Math.max(minRadius, Math.min(maxRadius, adaptiveRadius));
+}

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

@@ -0,0 +1,2 @@
+export { addLine3DBetweenPoints } from './addLine3DBetweenPoints';
+export { calculateAdaptiveSphereRadius } from './calculateAdaptiveSphereRadius';

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

@@ -0,0 +1,2 @@
+export { addLine3DBetweenPoints } from './addLine3DBetweenPoints';
+export { calculateAdaptiveSphereRadius } from './calculateAdaptiveSphereRadius';

package/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.js

@@ -99,28 +99,36 @@ function _findSvgLayer(element) {
     return internalDiv?.querySelector(':scope > .svg-layer') || null;
 }
 function _determineCorners(canvasPoints) {
-    const p0 = canvasPoints[0];
-    if (!p0 || canvasPoints.length < 2) {
+    const validPoints = canvasPoints.filter(Boolean);
+    const p0 = validPoints[0];
+    if (!p0 || validPoints.length < 2) {
         return { left: p0, right: p0, top: p0, bottom: p0 };
     }
-    const handlesLeftToRight = [canvasPoints[0], canvasPoints[1]].sort(_compareX);
-    const handlesTopToBottom = [canvasPoints[0], canvasPoints[1]].sort(_compareY);
-    const left = handlesLeftToRight[0];
-    const right = handlesLeftToRight[handlesLeftToRight.length - 1];
-    const top = handlesTopToBottom[0];
-    const bottom = handlesTopToBottom[handlesTopToBottom.length - 1];
+    let left = p0;
+    let right = p0;
+    let top = p0;
+    let bottom = p0;
+    for (let i = 1; i < validPoints.length; i++) {
+        const point = validPoints[i];
+        if (point[0] < left[0]) {
+            left = point;
+        }
+        if (point[0] > right[0]) {
+            right = point;
+        }
+        if (point[1] < top[1]) {
+            top = point;
+        }
+        if (point[1] > bottom[1]) {
+            bottom = point;
+        }
+    }
     return {
         left,
         top,
         bottom,
         right,
     };
-    function _compareX(a, b) {
-        return a[0] < b[0] ? -1 : 1;
-    }
-    function _compareY(a, b) {
-        return a[1] < b[1] ? -1 : 1;
-    }
 }
 function _estimateTextBoxSize(textLines) {
     const estimatedPadding = 25;

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

@@ -0,0 +1,6 @@
+import { type Types, type VolumeViewport } from '@cornerstonejs/core';
+export declare function getCenterAndRadiusInCanvas(points: Types.Point3[], viewport: Types.IStackViewport | VolumeViewport): {
+    center: Types.Point2;
+    radius: number;
+};
+export default getCenterAndRadiusInCanvas;

package/dist/esm/utilities/getCenterAndRadiusInCanvas.js

@@ -0,0 +1,26 @@
+import {} from '@cornerstonejs/core';
+import { vec2, vec3 } from 'gl-matrix';
+const EPSILON = 1e-4;
+export function getCenterAndRadiusInCanvas(points, viewport) {
+    const canvasPoints = points.map((p) => viewport.worldToCanvas(p));
+    const [cBottom, cTop, cLeft, cRight] = canvasPoints;
+    const center = [
+        (cBottom[0] + cTop[0]) / 2,
+        (cBottom[1] + cTop[1]) / 2,
+    ];
+    const worldHeight = vec3.distance(points[0], points[1]);
+    const worldWidth = vec3.distance(points[2], points[3]);
+    const canvasHeight = vec2.distance(cBottom, cTop);
+    const canvasWidth = vec2.distance(cLeft, cRight);
+    const scaleX = canvasWidth / worldWidth;
+    const scaleY = canvasHeight / worldHeight;
+    const worldRadius = worldHeight / 2;
+    const radius = Math.abs(scaleX - scaleY) > EPSILON
+        ? worldRadius * Math.min(scaleX, scaleY)
+        : canvasHeight / 2;
+    return {
+        center: center,
+        radius: Math.round(radius),
+    };
+}
+export default getCenterAndRadiusInCanvas;

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

@@ -0,0 +1,2 @@
+import type { VolumeViewport, Types } from '@cornerstonejs/core';
+export default function getEllipseWorldCoordinates(points: [Types.Point3, Types.Point3], viewport: Types.IStackViewport | VolumeViewport): Types.Point3[];

package/dist/esm/utilities/getEllipseWorldCoordinates.js

@@ -0,0 +1,26 @@
+import { vec3 } from 'gl-matrix';
+export default function getEllipseWorldCoordinates(points, viewport) {
+    const camera = viewport.getCamera();
+    const { viewUp, viewPlaneNormal } = camera;
+    const viewRight = vec3.create();
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+    const [centerWorld, endWorld] = points;
+    const centerToEndDistance = vec3.distance(centerWorld, endWorld);
+    const bottomWorld = vec3.create();
+    const topWorld = vec3.create();
+    const leftWorld = vec3.create();
+    const rightWorld = vec3.create();
+    for (let i = 0; i <= 2; i++) {
+        bottomWorld[i] = centerWorld[i] - viewUp[i] * centerToEndDistance;
+        topWorld[i] = centerWorld[i] + viewUp[i] * centerToEndDistance;
+        leftWorld[i] = centerWorld[i] - viewRight[i] * centerToEndDistance;
+        rightWorld[i] = centerWorld[i] + viewRight[i] * centerToEndDistance;
+    }
+    const ellipseWorldCoordinates = [
+        bottomWorld,
+        topWorld,
+        leftWorld,
+        rightWorld,
+    ];
+    return ellipseWorldCoordinates;
+}

package/dist/esm/utilities/getSphereBoundsInfo.js

@@ -1,6 +1,7 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { getBoundingBoxAroundShapeIJK } from './boundingBox';
+import getViewportICamera from './getViewportICamera';
 const { transformWorldToIndex } = csUtils;
 function _getSphereBoundsInfo(circlePoints, imageData, directionVectors) {
     const [bottom, top] = circlePoints;
@@ -32,7 +33,10 @@ function getSphereBoundsInfoFromViewport(circlePoints, imageData, viewport) {
     if (!viewport) {
         throw new Error('viewport is required in order to calculate the sphere bounds');
     }
-    const camera = viewport.getCamera();
+    const camera = getViewportICamera(viewport);
+    if (!camera.viewUp || !camera.viewPlaneNormal) {
+        throw new Error('viewport view plane is required in order to calculate the sphere bounds');
+    }
     const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
     const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
     const viewRight = vec3.create();

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

@@ -0,0 +1,4 @@
+import { type Types } from '@cornerstonejs/core';
+type ViewportICamera = Pick<Types.ICamera, 'focalPoint' | 'position' | 'viewPlaneNormal' | 'viewUp'>;
+export default function getViewportICamera(viewport: Types.IViewport, viewReference?: Types.ViewReference): Partial<ViewportICamera>;
+export {};

package/dist/esm/utilities/getViewportICamera.js

@@ -0,0 +1,23 @@
+import { utilities } from '@cornerstonejs/core';
+export default function getViewportICamera(viewport, viewReference = viewport.getViewReference()) {
+    const genericViewport = viewport;
+    const camera = (genericViewport.getResolvedView?.()?.toICamera?.() ||
+        viewport.getCamera?.() ||
+        {});
+    const focalPoint = utilities.clonePoint3(viewReference?.cameraFocalPoint || camera.focalPoint);
+    const viewPlaneNormal = utilities.clonePoint3(viewReference?.viewPlaneNormal || camera.viewPlaneNormal);
+    const viewUp = utilities.clonePoint3(viewReference?.viewUp || camera.viewUp);
+    const position = utilities.clonePoint3(camera.position ||
+        (focalPoint &&
+            viewPlaneNormal && [
+            focalPoint[0] - viewPlaneNormal[0],
+            focalPoint[1] - viewPlaneNormal[1],
+            focalPoint[2] - viewPlaneNormal[2],
+        ]));
+    return {
+        focalPoint,
+        position,
+        viewPlaneNormal,
+        viewUp,
+    };
+}

package/dist/esm/utilities/getViewportsForAnnotation.js

@@ -1,4 +1,5 @@
 import { getEnabledElements, utilities as csUtils } from '@cornerstonejs/core';
+import getViewportICamera from './getViewportICamera';
 const { isEqual } = csUtils;
 export default function getViewportsForAnnotation(annotation) {
     const { metadata } = annotation;
@@ -6,7 +7,10 @@ export default function getViewportsForAnnotation(annotation) {
         .filter((enabledElement) => {
         if (enabledElement.FrameOfReferenceUID === metadata.FrameOfReferenceUID) {
             const viewport = enabledElement.viewport;
-            const { viewPlaneNormal, viewUp } = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
+            if (!viewPlaneNormal) {
+                return false;
+            }
             return (isEqual(viewPlaneNormal, metadata.viewPlaneNormal) &&
                 (!metadata.viewUp || isEqual(viewUp, metadata.viewUp)));
         }

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

@@ -22,6 +22,7 @@ import * as viewportFilters from './viewportFilters';
 import * as orientation from './orientation';
 import * as cine from './cine';
 import * as boundingBox from './boundingBox';
+import * as draw3D from './draw3D';
 import * as planarFreehandROITool from './planarFreehandROITool';
 import * as rectangleROITool from './rectangleROITool';
 import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
@@ -42,4 +43,4 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-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, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+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, };

package/dist/esm/utilities/index.js

@@ -22,6 +22,7 @@ import * as viewportFilters from './viewportFilters';
 import * as orientation from './orientation';
 import * as cine from './cine';
 import * as boundingBox from './boundingBox';
+import * as draw3D from './draw3D';
 import * as planarFreehandROITool from './planarFreehandROITool';
 import * as rectangleROITool from './rectangleROITool';
 import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
@@ -42,4 +43,4 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-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, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+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, };

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

@@ -0,0 +1,5 @@
+type DragOwner = 'orientation-controller';
+export declare function beginOwnedDrag(viewportId: string, owner: DragOwner): boolean;
+export declare function endOwnedDrag(viewportId: string, owner: DragOwner): void;
+export declare function isDragOwnedBy(viewportId: string, owner: DragOwner): boolean;
+export {};

package/dist/esm/utilities/interactionDragCoordinator.js

@@ -0,0 +1,16 @@
+const dragOwnerByViewportId = new Map();
+export function beginOwnedDrag(viewportId, owner) {
+    if (dragOwnerByViewportId.has(viewportId)) {
+        return false;
+    }
+    dragOwnerByViewportId.set(viewportId, owner);
+    return true;
+}
+export function endOwnedDrag(viewportId, owner) {
+    if (dragOwnerByViewportId.get(viewportId) === owner) {
+        dragOwnerByViewportId.delete(viewportId);
+    }
+}
+export function isDragOwnedBy(viewportId, owner) {
+    return dragOwnerByViewportId.get(viewportId) === owner;
+}

package/dist/esm/utilities/math/basic/BasicStatsCalculator.js

@@ -1,3 +1,4 @@
+var _a;
 import { utilities } from '@cornerstonejs/core';
 import { Calculator, InstanceCalculator } from './Calculator';
 const { PointsManager } = utilities;
@@ -204,20 +205,21 @@ function basicGetStatistics(state, unit) {
     return named;
 }
 export class BasicStatsCalculator extends Calculator {
-    static { this.state = createBasicStatsState(true); }
     static statsInit(options) {
         if (!options.storePointData) {
             this.state.pointsInShape = null;
         }
         this.state = createBasicStatsState(options.storePointData);
     }
-    static { this.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
-        basicStatsCallback(this.state, newValue, pointLPS, pointIJK);
-    }; }
-    static { this.getStatistics = (options) => {
-        return basicGetStatistics(this.state, options?.unit);
-    }; }
 }
+_a = BasicStatsCalculator;
+BasicStatsCalculator.state = createBasicStatsState(true);
+BasicStatsCalculator.statsCallback = ({ value: newValue, pointLPS = null, pointIJK = null, }) => {
+    basicStatsCallback(_a.state, newValue, pointLPS, pointIJK);
+};
+BasicStatsCalculator.getStatistics = (options) => {
+    return basicGetStatistics(_a.state, options?.unit);
+};
 export class InstanceBasicStatsCalculator extends InstanceCalculator {
     constructor(options) {
         super(options);

package/dist/esm/utilities/pointInSurroundingSphereCallback.js

@@ -2,6 +2,7 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { pointInSphere } from './math/sphere';
 import { getBoundingBoxAroundShape } from './boundingBox';
+import getViewportICamera from './getViewportICamera';
 const { transformWorldToIndex } = csUtils;
 export function pointInSurroundingSphereCallback(imageData, circlePoints, callback, viewport) {
     const { boundsIJK, centerWorld, radiusWorld } = _getBounds(circlePoints, imageData, viewport);
@@ -51,7 +52,13 @@ function _getBounds(circlePoints, imageData, viewport) {
 function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
     const [bottom, top] = circlePoints;
     const dimensions = imageData.getDimensions();
-    const camera = viewport.getCamera();
+    const camera = getViewportICamera(viewport);
+    if (!camera.viewUp || !camera.viewPlaneNormal) {
+        return getBoundingBoxAroundShape([
+            transformWorldToIndex(imageData, top),
+            transformWorldToIndex(imageData, bottom),
+        ], dimensions);
+    }
     const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
     const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
     const viewRight = vec3.create();