@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.js

@@ -0,0 +1,399 @@
+import { vec3 } from 'gl-matrix';
+import { ViewportType } from '../../../enums';
+import renderingEngineCache from '../../renderingEngineCache';
+import GenericViewport from '../GenericViewport';
+import { getDimensionGroupReferenceContext, } from '../genericViewportReferenceCompatibility';
+import { getGenericViewportImageDataSet, isGenericViewportImageDataSet, } from '../genericViewportDataSetAccess';
+import { DefaultVolume3DDataProvider } from './DefaultVolume3DDataProvider';
+import { createVolume3DRenderPathResolver } from './Volume3DRenderPathResolver';
+import Volume3DResolvedView from './Volume3DResolvedView';
+import applyVolume3DCamera from './applyVolume3DCamera';
+import { getVolume3DProjectionSnapshot, } from './volume3DProjectionAdapter';
+class VolumeViewport3D extends GenericViewport {
+    static get useCustomRenderingPipeline() {
+        return false;
+    }
+    getUseCustomRenderingPipeline() {
+        return false;
+    }
+    setRendered() {
+        super.setRendered();
+    }
+    constructor(args) {
+        super(args);
+        this.type = ViewportType.VOLUME_3D_NEXT;
+        this.suppressEvents = false;
+        this.renderingEngineId = args.renderingEngineId;
+        this.canvas = args.canvas;
+        this.sWidth = args.sWidth;
+        this.sHeight = args.sHeight;
+        this.defaultOptions = args.defaultOptions || {};
+        this.element.style.position = this.element.style.position || 'relative';
+        this.element.style.overflow = 'hidden';
+        this.element.style.background = this.element.style.background || '#000';
+        this.dataProvider = args.dataProvider || new DefaultVolume3DDataProvider();
+        this.renderPathResolver =
+            args.renderPathResolver || createVolume3DRenderPathResolver();
+        const renderingEngine = renderingEngineCache.get(this.renderingEngineId);
+        const renderer = renderingEngine?.getRenderer(this.id);
+        if (!renderer) {
+            throw new Error('[VolumeViewport3D] No renderer available. Ensure WebGL is supported and the rendering engine has been properly initialized.');
+        }
+        renderer
+            .getActiveCamera()
+            .setParallelProjection(this.defaultOptions.parallelProjection ?? true);
+        this.renderContext = {
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+            type: '3d',
+            viewport: {
+                element: this.element,
+                options: {
+                    orientation: this.defaultOptions.orientation,
+                    parallelProjection: this.defaultOptions.parallelProjection,
+                },
+            },
+            display: {
+                requestRender: () => {
+                    this.requestRenderingEngineRender();
+                },
+            },
+            vtk: {
+                canvas: this.canvas,
+                renderer,
+            },
+        };
+        this.viewState = {
+            parallelProjection: this.defaultOptions.parallelProjection ?? true,
+        };
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+    }
+    async setDisplaySets(...entries) {
+        this.removeAllData();
+        for (const [index, { displaySetId, options = {} }] of entries.entries()) {
+            await this.addDisplaySet(displaySetId, {
+                ...options,
+                role: options.role ?? (index === 0 ? 'source' : 'overlay'),
+            });
+        }
+    }
+    async addDisplaySet(displaySetId, options = {}) {
+        const volumeOptions = options;
+        const renderMode = this.resolveRenderMode(displaySetId, volumeOptions.renderMode);
+        await super.addDisplaySet(displaySetId, {
+            renderMode,
+            role: volumeOptions.role,
+        });
+        if (renderMode === 'vtkVolume3d' && volumeOptions.role === 'source') {
+            this.primaryDataId = displaySetId;
+        }
+        this.setDefaultDataPresentation(displaySetId, {
+            visible: true,
+            opacity: 1,
+        });
+        this.viewState = this.getViewState();
+    }
+    getRenderingEngine() {
+        return renderingEngineCache.get(this.renderingEngineId);
+    }
+    getImageIds() {
+        const binding = this.getCurrentBinding();
+        if (!binding) {
+            return [];
+        }
+        const data = this.getVolume3DPayload(binding);
+        const rendering = this.getVolume3DRendering(binding);
+        if (!data ||
+            data.renderMode !== 'vtkVolume3d' ||
+            rendering.renderMode !== 'vtkVolume3d') {
+            return [];
+        }
+        return data.imageIds;
+    }
+    getRenderer() {
+        return this.renderContext.vtk.renderer;
+    }
+    getCanvas() {
+        return this.canvas;
+    }
+    getVtkActiveCamera() {
+        return this.getRenderer().getActiveCamera();
+    }
+    getViewState() {
+        return this.getRuntimeCamera();
+    }
+    setViewState(viewStatePatch) {
+        if (this.isDestroyed) {
+            return;
+        }
+        const previousCamera = this.getCameraForEvent();
+        applyVolume3DCamera(this.renderContext, viewStatePatch, {
+            resetClippingRange: true,
+        });
+        this.viewState = this.getRuntimeCamera();
+        this.modified(previousCamera);
+    }
+    getRuntimeCamera() {
+        const camera = this.getRenderer().getActiveCamera();
+        return {
+            clippingRange: camera.getClippingRange(),
+            focalPoint: camera.getFocalPoint(),
+            parallelProjection: camera.getParallelProjection(),
+            parallelScale: camera.getParallelScale(),
+            position: camera.getPosition(),
+            rotation: 0,
+            viewAngle: camera.getViewAngle(),
+            viewPlaneNormal: camera.getViewPlaneNormal(),
+            viewUp: camera.getViewUp(),
+        };
+    }
+    getResolvedView() {
+        return new Volume3DResolvedView({
+            camera: this.getViewState(),
+            canvas: this.canvas,
+            frameOfReferenceUID: this.resolveFrameOfReferenceUID(),
+            renderer: this.getRenderer(),
+        });
+    }
+    getViewReference(_viewRefSpecifier = {}) {
+        const binding = this.getCurrentBinding();
+        const data = binding ? this.getVolume3DPayload(binding) : undefined;
+        const camera = this.getViewState();
+        const FrameOfReferenceUID = this.getFrameOfReferenceUID();
+        const cameraFocalPoint = camera.focalPoint;
+        const viewPlaneNormal = camera.viewPlaneNormal;
+        const viewUp = camera.viewUp;
+        const viewReference = {
+            FrameOfReferenceUID,
+            dataId: binding?.data.id,
+            cameraFocalPoint,
+            viewPlaneNormal,
+            viewUp,
+        };
+        if (data?.renderMode === 'vtkVolume3d') {
+            viewReference.volumeId = data.volumeId;
+            Object.assign(viewReference, getDimensionGroupReferenceContext(data.imageVolume));
+        }
+        if (cameraFocalPoint && viewPlaneNormal && viewUp) {
+            viewReference.planeRestriction = {
+                FrameOfReferenceUID,
+                point: cameraFocalPoint,
+                inPlaneVector1: viewUp,
+                inPlaneVector2: vec3.cross(vec3.create(), viewUp, viewPlaneNormal),
+            };
+        }
+        return viewReference;
+    }
+    getVolumeId() {
+        const binding = this.getCurrentBinding();
+        if (!binding) {
+            return;
+        }
+        const data = this.getVolume3DPayload(binding);
+        const rendering = this.getVolume3DRendering(binding);
+        if (!data ||
+            data.renderMode !== 'vtkVolume3d' ||
+            rendering.renderMode !== 'vtkVolume3d') {
+            return;
+        }
+        return data.volumeId;
+    }
+    hasVolumeId(volumeId) {
+        return this.getActors().some((actorEntry) => actorEntry.referencedId === volumeId);
+    }
+    hasVolumeURI(volumeURI) {
+        return this.getActors().some((actorEntry) => String(actorEntry.referencedId || '').includes(volumeURI));
+    }
+    getImageData() {
+        return this.getCurrentBinding()?.getImageData?.();
+    }
+    getActors() {
+        const actors = [];
+        for (const binding of this.bindings.values()) {
+            const data = this.getVolume3DPayload(binding);
+            if (!data) {
+                continue;
+            }
+            actors.push(...this.getActorEntriesForRendering(this.getVolume3DRendering(binding), data));
+        }
+        return actors;
+    }
+    getDefaultActor() {
+        const binding = this.getCurrentBinding();
+        if (!binding) {
+            return this.getActors()[0];
+        }
+        const data = this.getVolume3DPayload(binding);
+        if (!data) {
+            return undefined;
+        }
+        return this.getActorEntriesForRendering(this.getVolume3DRendering(binding), data)[0];
+    }
+    resetViewState() {
+        const previousCamera = this.getCameraForEvent();
+        const renderer = this.getRenderer();
+        renderer.resetCamera();
+        renderer.resetCameraClippingRange();
+        this.viewState = this.getViewState();
+        this.render();
+        this.triggerCameraModifiedEvent(previousCamera);
+        this.triggerCameraResetEvent();
+        return true;
+    }
+    resetViewStateForResize() {
+        return this.resetViewState();
+    }
+    resize() {
+        if (this.isDestroyed) {
+            return;
+        }
+        this.sWidth = this.canvas.width;
+        this.sHeight = this.canvas.height;
+        this.resizeBindings();
+    }
+    render() {
+        if (this.isDestroyed) {
+            return;
+        }
+        if (!this.renderBindings()) {
+            this.requestRenderingEngineRender();
+        }
+    }
+    onDestroy() {
+        this.primaryDataId = undefined;
+    }
+    getProjectionSnapshot() {
+        const snapshot = getVolume3DProjectionSnapshot({
+            viewport: this,
+            canvasHeight: this.canvas.clientHeight || this.element.clientHeight,
+            canvasWidth: this.canvas.clientWidth || this.element.clientWidth,
+            camera: this.getViewState(),
+            frameOfReferenceUID: this.resolveFrameOfReferenceUID(),
+            resolvedView: this.getResolvedView(),
+        });
+        if (!snapshot) {
+            throw new Error('[VolumeViewport3D] Unable to resolve projection snapshot');
+        }
+        return snapshot;
+    }
+    getCurrentBinding() {
+        if (this.primaryDataId) {
+            return this.getBinding(this.primaryDataId) ?? this.getFirstBinding();
+        }
+        return this.getFirstBinding();
+    }
+    getReferenceViewContexts() {
+        const contexts = [];
+        const camera = this.getViewState();
+        for (const [dataId, binding] of this.bindings.entries()) {
+            const data = this.getVolume3DPayload(binding);
+            const volumeId = data?.renderMode === 'vtkVolume3d' ? data.volumeId : undefined;
+            contexts.push({
+                dataId,
+                dataIds: [binding.data.id],
+                frameOfReferenceUID: binding.getFrameOfReferenceUID() ?? this.getFrameOfReferenceUID(),
+                imageIds: data?.renderMode === 'vtkVolume3d' ? data.imageIds : undefined,
+                volumeId,
+                volumeIds: volumeId ? [volumeId] : undefined,
+                cameraFocalPoint: camera.focalPoint,
+                viewPlaneNormal: camera.viewPlaneNormal,
+                ...(data?.renderMode === 'vtkVolume3d'
+                    ? getDimensionGroupReferenceContext(data.imageVolume)
+                    : {}),
+            });
+        }
+        return contexts.length ? contexts : super.getReferenceViewContexts();
+    }
+    requestRenderingEngineRender() {
+        const renderingEngine = renderingEngineCache.get(this.renderingEngineId);
+        if (renderingEngine) {
+            renderingEngine.renderViewport(this.id);
+        }
+    }
+    resolveRenderMode(dataId, requestedRenderMode = 'auto') {
+        if (requestedRenderMode && requestedRenderMode !== 'auto') {
+            return requestedRenderMode;
+        }
+        const dataSet = this.getDataSet(dataId);
+        if (dataSet?.imageIds?.length) {
+            return 'vtkVolume3d';
+        }
+        return 'vtkGeometry3d';
+    }
+    getDataSet(dataId) {
+        const dataSet = getGenericViewportImageDataSet(dataId);
+        if (!isVolume3DRegisteredDataSet(dataSet)) {
+            return;
+        }
+        return dataSet;
+    }
+    getVolume3DPayload(binding) {
+        if (!isVolume3DData(binding.data)) {
+            return;
+        }
+        return binding.data;
+    }
+    resolveFrameOfReferenceUID() {
+        const binding = this.getCurrentBinding();
+        if (!binding) {
+            return;
+        }
+        const data = this.getVolume3DPayload(binding);
+        const rendering = this.getVolume3DRendering(binding);
+        if (!data) {
+            return;
+        }
+        if (data.renderMode === 'vtkVolume3d') {
+            return data.imageVolume.metadata?.FrameOfReferenceUID;
+        }
+        if (rendering.renderMode === 'vtkGeometry3d') {
+            return rendering.frameOfReferenceUID;
+        }
+    }
+    getVolume3DRendering(binding) {
+        if (!isVolume3DRendering(binding.rendering)) {
+            throw new Error('[VolumeViewport3D] Binding render mode is not a supported 3D rendering');
+        }
+        return binding.rendering;
+    }
+    getActorEntriesForRendering(rendering, data) {
+        if (rendering.renderMode === 'vtkVolume3d' &&
+            data.renderMode === 'vtkVolume3d') {
+            return [
+                {
+                    actor: rendering.actor,
+                    referencedId: data.volumeId,
+                    uid: rendering.actorEntryUID,
+                },
+            ];
+        }
+        if (rendering.renderMode === 'vtkGeometry3d') {
+            return rendering.actors;
+        }
+        return [];
+    }
+}
+export default VolumeViewport3D;
+function isVolume3DData(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const payload = data;
+    return ((payload.type === 'image' && payload.renderMode === 'vtkVolume3d') ||
+        (payload.type === 'geometry' && payload.renderMode === 'vtkGeometry3d'));
+}
+function isVolume3DRendering(rendering) {
+    return (rendering.renderMode === 'vtkVolume3d' ||
+        rendering.renderMode === 'vtkGeometry3d');
+}
+function isVolume3DRegisteredDataSet(value) {
+    if (!isGenericViewportImageDataSet(value)) {
+        return false;
+    }
+    return ((value.geometryId === undefined || typeof value.geometryId === 'string') &&
+        (value.volumeId === undefined || typeof value.volumeId === 'string') &&
+        (value.geometryLoadOptions === undefined ||
+            (typeof value.geometryLoadOptions === 'object' &&
+                !Array.isArray(value.geometryLoadOptions))));
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3DTypes.d.ts

@@ -0,0 +1,88 @@
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+import type { GeometryOptions } from '../../../loaders/geometryLoader';
+import type { ActorEntry, ICamera, IGeometry, IImageVolume, RGB, VOIRange, Point3 } from '../../../types';
+import type { ViewportInput } from '../../../types/IViewport';
+import type ViewportInputOptions from '../../../types/ViewportInputOptions';
+import type { InterpolationType } from '../../../enums';
+import type { BaseViewportRenderContext, BasePresentationProps, BindingRole, DataProvider, LoadedData, MountedRendering, RenderPathResolver } from '../ViewportArchitectureTypes';
+import type { ViewportCameraBase } from '../ViewportCameraTypes';
+export type Volume3DRenderMode = 'vtkVolume3d' | 'vtkGeometry3d';
+export type Volume3DRequestedRenderMode = Volume3DRenderMode | 'auto';
+export interface Volume3DRegisteredDataSet {
+    geometryId?: string;
+    geometryLoadOptions?: GeometryOptions;
+    imageIds?: string[];
+    volumeId?: string;
+}
+export interface Volume3DSetDataOptions {
+    renderMode?: Volume3DRequestedRenderMode;
+    role?: BindingRole;
+}
+export interface Volume3DVolumePayload {
+    imageIds: string[];
+    imageVolume: IImageVolume;
+    renderMode: 'vtkVolume3d';
+    volumeId: string;
+}
+export interface Volume3DGeometryPayload {
+    geometry: IGeometry;
+    geometryId: string;
+    renderMode: 'vtkGeometry3d';
+}
+export type Volume3DPayload = Volume3DVolumePayload | Volume3DGeometryPayload;
+export interface Volume3DPresentationProps extends BasePresentationProps {
+    color?: RGB;
+    invert?: boolean;
+    voiRange?: VOIRange;
+}
+export interface Volume3DProperties {
+    interpolationType?: InterpolationType;
+    sampleDistanceMultiplier?: number;
+}
+export type Volume3DDataPresentation = Volume3DPresentationProps & Volume3DProperties;
+export interface Volume3DCamera extends ICamera, ViewportCameraBase<Point3> {
+}
+export interface Volume3DDataProvider extends DataProvider {
+    load(dataId: string, options?: {
+        renderMode: Volume3DRenderMode;
+    }): Promise<LoadedData<Volume3DPayload>>;
+}
+export interface VolumeViewport3DInput extends ViewportInput {
+    dataProvider?: DataProvider;
+    renderPathResolver?: RenderPathResolver;
+}
+export interface Volume3DViewportRenderContext extends BaseViewportRenderContext {
+    type: '3d';
+    viewport: {
+        element: HTMLDivElement;
+        options: Pick<ViewportInputOptions, 'orientation' | 'parallelProjection'>;
+    };
+    display: {
+        requestRender(): void;
+    };
+    vtk: {
+        canvas: HTMLCanvasElement;
+        renderer: vtkRenderer;
+    };
+}
+type Volume3DContextBase = Pick<Volume3DViewportRenderContext, 'display' | 'type' | 'viewport' | 'viewportId' | 'vtk'>;
+export type Volume3DVtkVolumeAdapterContext = Volume3DContextBase;
+export type Volume3DVtkGeometryAdapterContext = Volume3DContextBase;
+export type Volume3DVolumeRendering = MountedRendering<{
+    renderMode: 'vtkVolume3d';
+    actorEntryUID: string;
+    actor: vtkVolume;
+    defaultVOIRange?: VOIRange;
+    imageVolume: IImageVolume;
+    mapper: vtkVolumeMapper;
+    removeStreamingSubscriptions?: () => void;
+}>;
+export type Volume3DGeometryRendering = MountedRendering<{
+    renderMode: 'vtkGeometry3d';
+    actors: ActorEntry[];
+    frameOfReferenceUID?: string;
+}>;
+export type Volume3DRendering = Volume3DVolumeRendering | Volume3DGeometryRendering;
+export {};

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionAdapter.d.ts

@@ -0,0 +1,7 @@
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
+import { getVolume3DProjectionSnapshot } from './volume3DProjectionSnapshot';
+import { type Volume3DProjectionPresentation, type Volume3DProjectionSnapshot } from './Volume3DProjectionTypes';
+import type { Volume3DCamera } from './viewport3DTypes';
+export { getVolume3DProjectionSnapshot };
+export type { Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, } from './Volume3DProjectionTypes';
+export declare const volume3DProjectionAdapter: ViewportProjectionAdapter<Volume3DCamera, Volume3DProjectionPresentation, Volume3DProjectionSnapshot>;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionAdapter.js

@@ -0,0 +1,27 @@
+import { ViewportType } from '../../../enums';
+import applyVolume3DCamera from './applyVolume3DCamera';
+import { getVolume3DProjectionPresentation, withVolume3DProjectionPresentation, } from './volume3DProjectionPresentation';
+import { getVolume3DProjectionSnapshot } from './volume3DProjectionSnapshot';
+import { VOLUME3D_PROJECTION_ID, } from './Volume3DProjectionTypes';
+export { getVolume3DProjectionSnapshot };
+function isVolume3DRenderTarget(target) {
+    return Boolean(target &&
+        typeof target === 'object' &&
+        'vtk' in target &&
+        target.vtk?.renderer);
+}
+export const volume3DProjectionAdapter = {
+    id: VOLUME3D_PROJECTION_ID,
+    viewportTypes: [ViewportType.VOLUME_3D_NEXT],
+    getSnapshot: (request) => getVolume3DProjectionSnapshot(request),
+    getPresentation: (snapshot) => getVolume3DProjectionPresentation(snapshot),
+    withPresentation: (snapshot, presentation, _options) => withVolume3DProjectionPresentation(snapshot, presentation),
+    applyToRenderer: (snapshot, target) => {
+        if (!isVolume3DRenderTarget(target)) {
+            return;
+        }
+        applyVolume3DCamera(target, snapshot.rendererCamera, {
+            resetClippingRange: true,
+        });
+    },
+};

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionCamera.d.ts

@@ -0,0 +1,12 @@
+import type { ICamera, Point3 } from '../../../types';
+import type { ProjectionScale } from '../ViewportProjectionTypes';
+import type { Volume3DCamera } from './viewport3DTypes';
+export declare function cloneVolume3DCamera(camera: Volume3DCamera & ICamera): Volume3DCamera & ICamera;
+export declare function getVolume3DProjectionScale(args: {
+    camera: Volume3DCamera & ICamera;
+    canvasHeight: number;
+}): ProjectionScale | undefined;
+export declare function getVolume3DProjectionPosition(camera: Volume3DCamera & ICamera): {
+    kind: "focalPoint";
+    worldPoint: Point3;
+};

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionCamera.js

@@ -0,0 +1,35 @@
+function clonePoint2(point) {
+    return point ? [point[0], point[1]] : undefined;
+}
+function clonePoint3(point) {
+    return point ? [point[0], point[1], point[2]] : undefined;
+}
+export function cloneVolume3DCamera(camera) {
+    return {
+        ...camera,
+        clippingRange: clonePoint2(camera.clippingRange),
+        focalPoint: clonePoint3(camera.focalPoint),
+        position: clonePoint3(camera.position),
+        viewPlaneNormal: clonePoint3(camera.viewPlaneNormal),
+        viewUp: clonePoint3(camera.viewUp),
+    };
+}
+export function getVolume3DProjectionScale(args) {
+    const { camera, canvasHeight } = args;
+    if (typeof camera.parallelScale !== 'number') {
+        return;
+    }
+    return {
+        kind: 'physical',
+        mmPerCanvasPixel: (camera.parallelScale * 2) / Math.max(canvasHeight, 1),
+    };
+}
+export function getVolume3DProjectionPosition(camera) {
+    if (!camera.focalPoint) {
+        return;
+    }
+    return {
+        kind: 'focalPoint',
+        worldPoint: clonePoint3(camera.focalPoint),
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionPresentation.d.ts

@@ -0,0 +1,4 @@
+import type { Volume3DProjectionPresentation, Volume3DProjectionSnapshot } from './Volume3DProjectionTypes';
+import type { Volume3DCamera } from './viewport3DTypes';
+export declare function getVolume3DProjectionPresentation(snapshot: Volume3DProjectionSnapshot): Volume3DProjectionPresentation;
+export declare function withVolume3DProjectionPresentation(snapshot: Volume3DProjectionSnapshot, presentation: Partial<Volume3DProjectionPresentation>): Volume3DCamera;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionPresentation.js

@@ -0,0 +1,22 @@
+import { cloneVolume3DCamera } from './volume3DProjectionCamera';
+function isWrappedVolume3DPresentation(presentation) {
+    return Object.prototype.hasOwnProperty.call(presentation, 'camera');
+}
+function getCameraPatch(presentation) {
+    if (isWrappedVolume3DPresentation(presentation)) {
+        return presentation.camera ?? {};
+    }
+    return presentation;
+}
+export function getVolume3DProjectionPresentation(snapshot) {
+    return {
+        ...snapshot.presentation,
+        camera: cloneVolume3DCamera(snapshot.presentation.camera),
+    };
+}
+export function withVolume3DProjectionPresentation(snapshot, presentation) {
+    return cloneVolume3DCamera({
+        ...snapshot.presentation.camera,
+        ...getCameraPatch(presentation),
+    });
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionSnapshot.d.ts

@@ -0,0 +1,2 @@
+import { type Volume3DProjectionRequest, type Volume3DProjectionSnapshot } from './Volume3DProjectionTypes';
+export declare function getVolume3DProjectionSnapshot(request: Volume3DProjectionRequest): Volume3DProjectionSnapshot | undefined;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/volume3DProjectionSnapshot.js

@@ -0,0 +1,52 @@
+import { cloneVolume3DCamera, getVolume3DProjectionPosition, getVolume3DProjectionScale, } from './volume3DProjectionCamera';
+import { VOLUME3D_PROJECTION_ID, } from './Volume3DProjectionTypes';
+export function getVolume3DProjectionSnapshot(request) {
+    const { viewport } = request;
+    const resolvedView = request.resolvedView ?? viewport.getResolvedView?.();
+    const viewState = request.camera ?? viewport.getViewState?.();
+    const rendererCamera = resolvedView?.toICamera() ?? viewState;
+    if (!rendererCamera) {
+        return;
+    }
+    const camera = cloneVolume3DCamera(rendererCamera);
+    const canvasWidth = request.canvasWidth ??
+        viewport.canvas?.clientWidth ??
+        viewport.element?.clientWidth ??
+        1;
+    const canvasHeight = request.canvasHeight ??
+        viewport.canvas?.clientHeight ??
+        viewport.element?.clientHeight ??
+        1;
+    const frameOfReferenceUID = request.frameOfReferenceUID ??
+        resolvedView?.getFrameOfReferenceUID() ??
+        viewport.getFrameOfReferenceUID?.();
+    return {
+        kind: VOLUME3D_PROJECTION_ID,
+        adapterId: VOLUME3D_PROJECTION_ID,
+        canvasHeight,
+        canvasWidth,
+        dataId: request.dataId,
+        frameOfReferenceUID,
+        presentation: {
+            camera: cloneVolume3DCamera(camera),
+            position: getVolume3DProjectionPosition(camera),
+            rotation: camera.rotation,
+            scale: getVolume3DProjectionScale({ camera, canvasHeight }),
+        },
+        rendererCamera: cloneVolume3DCamera(camera),
+        resolvedView,
+        spaces: {
+            canvas: Boolean(resolvedView),
+            renderer: true,
+            world: Boolean(resolvedView || camera.focalPoint),
+        },
+        transforms: resolvedView
+            ? {
+                canvasToWorld: (point) => resolvedView.canvasToWorld(point),
+                worldToCanvas: (point) => resolvedView.worldToCanvas(point),
+            }
+            : undefined,
+        viewState: cloneVolume3DCamera(camera),
+        viewportType: viewport.type,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/vtkVolume3DInitialCamera.d.ts

@@ -0,0 +1,3 @@
+import type { IImageVolume } from '../../../types';
+import type { Volume3DCamera, Volume3DVtkVolumeAdapterContext } from './viewport3DTypes';
+export declare function getInitialVolume3DCamera(ctx: Volume3DVtkVolumeAdapterContext, imageVolume: IImageVolume): Partial<Volume3DCamera> | undefined;