@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/tools/segmentation/strategies/utils/handleUseSegmentCenterIndex.js

@@ -1,8 +1,9 @@
 export function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
-    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, } = operationData;
+    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, labelValue, } = operationData;
+    const activeLabelValue = labelValue ?? segmentIndex;
     const { hasPreviewIndex, hasSegmentIndex, segmentIndex: centerSegmentIndex, } = centerSegmentIndexInfo;
     if (centerSegmentIndex === 0 && hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -15,7 +16,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === 0 || existingValue !== segmentIndex) {
+        if (existingValue === 0 || existingValue !== activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -23,7 +24,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (previewOnHover) {
@@ -36,7 +37,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
         return;
     }
     if (centerSegmentIndex === 0 && !hasSegmentIndex && !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         if (existingValue === previewSegmentIndex) {
@@ -48,7 +49,7 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
     if (centerSegmentIndex === previewSegmentIndex &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
@@ -57,25 +58,25 @@ export function handleUseSegmentCenterIndex({ operationData, existingValue, inde
     if (centerSegmentIndex === previewSegmentIndex &&
         !hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);
         return;
     }
-    if (centerSegmentIndex === segmentIndex &&
+    if (centerSegmentIndex === activeLabelValue &&
         hasSegmentIndex &&
         !hasPreviewIndex) {
-        if (existingValue === segmentIndex) {
+        if (existingValue === activeLabelValue) {
             return;
         }
         memo.voxelManager.setAtIndex(index, previewSegmentIndex);

package/dist/esm/tools/segmentation/strategies/utils/labelmapOverlap.d.ts

@@ -0,0 +1,4 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+import { eraseCrossLayerOverwrites } from './crossLayerErase';
+declare function prepareOverlapOperationData(operationData: InitializedOperationData): void;
+export { eraseCrossLayerOverwrites, prepareOverlapOperationData };

package/dist/esm/tools/segmentation/strategies/utils/labelmapOverlap.js

@@ -0,0 +1,41 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { beginLabelmapEditTransaction, resolveLabelmapLayerEditTarget, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { eraseCrossLayerOverwrites } from './crossLayerErase';
+import { resolveOverwriteSegmentIndices } from './overwritePolicy';
+function prepareOverlapOperationData(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    operationData.overwriteSegmentIndices =
+        resolveOverwriteSegmentIndices(operationData);
+    const transaction = beginLabelmapEditTransaction(segmentation, {
+        segmentIndex: operationData.segmentIndex,
+        overwriteSegmentIndices: operationData.overwriteSegmentIndices,
+        segmentationVoxelManager: operationData.segmentationVoxelManager,
+        segmentationImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+    });
+    operationData.labelmapEditTransaction = transaction;
+    operationData.labelValue = transaction.labelValue;
+    operationData.labelmapId = transaction.labelmapId;
+    operationData.crossLayerEraseBindings = transaction.crossLayerEraseBindings;
+    if (transaction.movedSegment && transaction.activeLayer) {
+        const target = resolveLabelmapLayerEditTarget(transaction.activeLayer, {
+            viewport: operationData.viewport,
+            imageId: operationData.imageId,
+            sourceLayer: transaction.sourceLayer,
+        });
+        if (target.imageId) {
+            operationData.imageId = target.imageId;
+        }
+        if (target.imageData) {
+            operationData.segmentationImageData = target.imageData;
+        }
+        if (target.voxelManager) {
+            operationData.segmentationVoxelManager = target.voxelManager;
+        }
+    }
+}
+export { eraseCrossLayerOverwrites, prepareOverlapOperationData };

package/dist/esm/tools/segmentation/strategies/utils/overwritePolicy.d.ts

@@ -0,0 +1,3 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function resolveOverwriteSegmentIndices(operationData: InitializedOperationData): number[];
+export { resolveOverwriteSegmentIndices };

package/dist/esm/tools/segmentation/strategies/utils/overwritePolicy.js

@@ -0,0 +1,31 @@
+import { getConfig } from '../../../../config';
+import { SegmentationRepresentations } from '../../../../enums';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { getSegmentationRepresentation } from '../../../../stateManagement/segmentation/getSegmentationRepresentation';
+function resolveOverwriteSegmentIndices(operationData) {
+    const { segmentationId, segmentIndex, segmentsLocked, viewport } = operationData;
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation || segmentIndex === 0) {
+        return [];
+    }
+    const overwriteMode = getConfig().segmentation?.overwriteMode ?? 'all';
+    if (overwriteMode === 'none') {
+        return [];
+    }
+    const allSegmentIndices = Object.keys(segmentation.segments)
+        .map(Number)
+        .filter((candidateSegmentIndex) => candidateSegmentIndex !== segmentIndex &&
+        !segmentsLocked.includes(candidateSegmentIndex));
+    if (overwriteMode === 'all') {
+        return allSegmentIndices;
+    }
+    const representation = getSegmentationRepresentation(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    });
+    if (!representation?.visible) {
+        return [];
+    }
+    return allSegmentIndices.filter((candidateSegmentIndex) => representation.segments[candidateSegmentIndex]?.visible !== false);
+}
+export { resolveOverwriteSegmentIndices };

package/dist/esm/tools/segmentation/strategies/utils/segmentSeparation.d.ts

@@ -0,0 +1,3 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function separateSegmentIfNeeded(operationData: InitializedOperationData): void;
+export { separateSegmentIfNeeded };

package/dist/esm/tools/segmentation/strategies/utils/segmentSeparation.js

@@ -0,0 +1,38 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { beginLabelmapEditTransaction, resolveLabelmapLayerEditTarget, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+function separateSegmentIfNeeded(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation || !operationData.segmentIndex) {
+        return;
+    }
+    const transaction = beginLabelmapEditTransaction(segmentation, {
+        segmentIndex: operationData.segmentIndex,
+        overwriteSegmentIndices: operationData.overwriteSegmentIndices,
+        segmentationVoxelManager: operationData.segmentationVoxelManager,
+        segmentationImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+    });
+    operationData.labelmapEditTransaction = transaction;
+    operationData.labelmapId = transaction.labelmapId;
+    operationData.labelValue = transaction.labelValue;
+    operationData.crossLayerEraseBindings = transaction.crossLayerEraseBindings;
+    if (!transaction.movedSegment || !transaction.activeLayer) {
+        return;
+    }
+    const target = resolveLabelmapLayerEditTarget(transaction.activeLayer, {
+        viewport: operationData.viewport,
+        imageId: operationData.imageId,
+        sourceLayer: transaction.sourceLayer,
+    });
+    if (target.imageId) {
+        operationData.imageId = target.imageId;
+    }
+    if (target.imageData) {
+        operationData.segmentationImageData = target.imageData;
+    }
+    if (target.voxelManager) {
+        operationData.segmentationVoxelManager = target.voxelManager;
+    }
+}
+export { separateSegmentIfNeeded };

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

@@ -0,0 +1,19 @@
+import { type Types } from '@cornerstonejs/core';
+declare class LazyBrushEditController {
+    private strokePointsWorld;
+    private previewPoints;
+    private pendingPreviewCleanup;
+    reset(): void;
+    clearPendingCleanup(): void;
+    appendStrokePoint(worldPoint: Types.Point3): void;
+    getStrokePointsWorld(): Types.Point3[];
+    capturePreviewCircle(hoverData: any): void;
+    scheduleCleanup({ element, centerCanvas, viewportId, segmentationId, refreshCursor, }: {
+        element: HTMLDivElement;
+        centerCanvas: Types.Point2;
+        viewportId: string;
+        segmentationId: string;
+        refreshCursor: (element: HTMLDivElement, centerCanvas: Types.Point2) => void;
+    }): void;
+}
+export default LazyBrushEditController;

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

@@ -0,0 +1,55 @@
+import { eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { appendLazyBrushPreviewCircle, appendLazyBrushStrokePoint, } from './lazyBrushPreview';
+class LazyBrushEditController {
+    constructor() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+        this.pendingPreviewCleanup = null;
+    }
+    reset() {
+        this.strokePointsWorld = [];
+        this.previewPoints = [];
+    }
+    clearPendingCleanup() {
+        if (!this.pendingPreviewCleanup) {
+            return;
+        }
+        eventTarget.removeEventListener(Events.SEGMENTATION_RENDERED, this.pendingPreviewCleanup.listener);
+        this.pendingPreviewCleanup = null;
+    }
+    appendStrokePoint(worldPoint) {
+        this.strokePointsWorld = appendLazyBrushStrokePoint(this.strokePointsWorld, worldPoint);
+    }
+    getStrokePointsWorld() {
+        return this.strokePointsWorld;
+    }
+    capturePreviewCircle(hoverData) {
+        if (!hoverData) {
+            return;
+        }
+        const circlePoints = hoverData.brushCursor?.data?.editPoints;
+        this.previewPoints = appendLazyBrushPreviewCircle(this.previewPoints, circlePoints);
+        hoverData.brushCursor.data.handles.points = this.previewPoints;
+    }
+    scheduleCleanup({ element, centerCanvas, viewportId, segmentationId, refreshCursor, }) {
+        this.clearPendingCleanup();
+        const listener = ((evt) => {
+            const detail = evt.detail;
+            if (detail.viewportId !== viewportId ||
+                detail.segmentationId !== segmentationId) {
+                return;
+            }
+            this.clearPendingCleanup();
+            this.reset();
+            refreshCursor(element, centerCanvas);
+        });
+        this.pendingPreviewCleanup = {
+            viewportId,
+            segmentationId,
+            listener,
+        };
+        eventTarget.addEventListener(Events.SEGMENTATION_RENDERED, listener);
+    }
+}
+export default LazyBrushEditController;

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

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function appendLazyBrushStrokePoint(points?: Types.Point3[], point?: Types.Point3): Types.Point3[];
+export declare function appendLazyBrushPreviewCircle(existingPoints?: Types.Point3[], circlePoints?: Types.Point3[]): Types.Point3[];

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

@@ -0,0 +1,34 @@
+const EPSILON = 1e-3;
+function clonePoint(point) {
+    return [point[0], point[1], point[2]];
+}
+function isSamePoint(a, b) {
+    return (Math.abs(a[0] - b[0]) < EPSILON &&
+        Math.abs(a[1] - b[1]) < EPSILON &&
+        Math.abs(a[2] - b[2]) < EPSILON);
+}
+export function appendLazyBrushStrokePoint(points = [], point) {
+    if (!point) {
+        return points;
+    }
+    if (points.length && isSamePoint(points[points.length - 1], point)) {
+        return points;
+    }
+    return [...points, clonePoint(point)];
+}
+export function appendLazyBrushPreviewCircle(existingPoints = [], circlePoints = []) {
+    if (!circlePoints.length) {
+        return existingPoints;
+    }
+    const nextCircle = circlePoints.map((point) => clonePoint(point));
+    if (!existingPoints.length) {
+        return nextCircle;
+    }
+    const previousCircle = existingPoints.slice(-nextCircle.length);
+    const isDuplicateCircle = previousCircle.length === nextCircle.length &&
+        previousCircle.every((point, index) => isSamePoint(point, nextCircle[index]));
+    if (isDuplicateCircle) {
+        return existingPoints;
+    }
+    return [...existingPoints, ...nextCircle];
+}

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/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

@@ -27,6 +27,7 @@ export type Segmentation = {
     segments: {
         [segmentIndex: number]: Segment;
     };
+    segmentOrder?: number[];
     representationData: RepresentationsData;
     cachedStats: {
         [key: string]: unknown;
@@ -37,6 +38,7 @@ export type LabelmapRenderingConfig = {
     ofun: vtkPiecewiseFunction;
     colorLUTIndex: number;
     blendMode?: coreEnums.BlendModes;
+    useSliceRendering?: boolean;
 };
 export type ContourRenderingConfig = {};
 export type SurfaceRenderingConfig = {};
@@ -80,6 +82,7 @@ export type SegmentationPublicInput = {
         segments?: {
             [segmentIndex: number]: Partial<Segment>;
         };
+        segmentOrder?: number[];
         label?: string;
         fallbackLabel?: string;
         cachedStats?: {
@@ -93,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/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/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();