@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/ViewportProjectionTypes.d.ts

@@ -0,0 +1,101 @@
+import type { ICamera, Point2, Point3 } from '../../types';
+import type DisplayArea from '../../types/displayArea';
+import type { ViewPresentationSelector } from '../../types/IViewport';
+import type ViewportType from '../../enums/ViewportType';
+export type ProjectionScale = {
+    kind: 'fit';
+    value: number;
+} | {
+    kind: 'fitWidth';
+    value: number;
+} | {
+    kind: 'fitHeight';
+    value: number;
+} | {
+    kind: 'displayArea';
+    value: number;
+    area: DisplayArea;
+} | {
+    kind: 'nativePixel';
+    pixelsPerCanvasPixel: number;
+} | {
+    kind: 'physical';
+    mmPerCanvasPixel: number;
+} | {
+    kind: 'signal';
+    samplesPerCanvasPixel: number;
+    valueUnitsPerCanvasPixel: number;
+};
+export type ProjectionPosition = {
+    kind: 'anchor';
+    worldPoint?: Point3;
+    canvasPoint: Point2;
+} | {
+    kind: 'imagePoint';
+    imagePoint: Point2;
+    canvasPoint: Point2;
+} | {
+    kind: 'mediaPoint';
+    mediaPoint: Point2;
+    canvasPoint: Point2;
+} | {
+    kind: 'signalPoint';
+    sampleIndex: number;
+    value: number;
+    channelIndex: number;
+    canvasPoint: Point2;
+} | {
+    kind: 'focalPoint';
+    worldPoint: Point3;
+};
+export interface ProjectionPresentation<TDisplayArea = DisplayArea> {
+    rotation?: number;
+    displayArea?: TDisplayArea;
+    zoom?: number;
+    pan?: Point2;
+    scale?: ProjectionScale;
+    position?: ProjectionPosition;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+}
+export interface ProjectionSpaces {
+    canvas?: boolean;
+    world?: boolean;
+    image?: boolean;
+    renderer?: boolean;
+}
+export interface ProjectionTransforms {
+    canvasToWorld?(point: Point2): Point3;
+    worldToCanvas?(point: Point3): Point2;
+}
+export interface ProjectionSnapshot<TViewState = unknown, TProjectionPresentation extends ProjectionPresentation<unknown> = ProjectionPresentation> {
+    kind: string;
+    adapterId: string;
+    viewportType?: ViewportType | string;
+    dataId?: string;
+    frameOfReferenceUID?: string;
+    spaces: ProjectionSpaces;
+    transforms?: ProjectionTransforms;
+    presentation: TProjectionPresentation;
+    rendererCamera?: ICamera<unknown>;
+    viewState?: TViewState;
+}
+export interface ProjectionRequest<TViewport = unknown> {
+    viewport: TViewport;
+    kind?: string;
+    dataId?: string;
+    viewportType?: ViewportType | string;
+    selector?: ViewPresentationSelector;
+}
+export interface ProjectionWriteOptions {
+    anchorCanvas?: Point2;
+    preserveDisplayArea?: boolean;
+}
+export interface ViewportProjectionAdapter<TViewState = unknown, TPresentation = unknown, TSnapshot extends ProjectionSnapshot<TViewState, ProjectionPresentation<unknown>> = ProjectionSnapshot<TViewState>> {
+    id: string;
+    viewportTypes: Array<ViewportType | string>;
+    getSnapshot(request: ProjectionRequest): TSnapshot | undefined;
+    getPresentation(snapshot: TSnapshot, selector?: ViewPresentationSelector): TPresentation;
+    withPresentation(snapshot: TSnapshot, presentation: Partial<TPresentation>, options?: ProjectionWriteOptions): TViewState;
+    applyToRenderer?(snapshot: TSnapshot, target: unknown): void;
+}

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

@@ -0,0 +1,8 @@
+import type { LoadedData } from '../ViewportArchitectureTypes';
+import type { Volume3DDataProvider, Volume3DGeometryPayload, Volume3DVolumePayload } from './viewport3DTypes';
+export declare class DefaultVolume3DDataProvider implements Volume3DDataProvider {
+    load(dataId: string, options?: {
+        renderMode: 'vtkVolume3d' | 'vtkGeometry3d';
+    }): Promise<LoadedData<Volume3DVolumePayload | Volume3DGeometryPayload>>;
+    private getDataSet;
+}

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

@@ -0,0 +1,58 @@
+import cache from '../../../cache/cache';
+import { loadAndCacheGeometry } from '../../../loaders/geometryLoader';
+import { createAndCacheVolume } from '../../../loaders/volumeLoader';
+import resolveViewportVolumeId from '../../helpers/resolveViewportVolumeId';
+import { getGenericViewportImageDataSet, isGenericViewportImageDataSet, } from '../genericViewportDataSetAccess';
+export class DefaultVolume3DDataProvider {
+    async load(dataId, options) {
+        if (!options) {
+            throw new Error(`[VolumeViewport3D] No load options were provided for ${dataId}`);
+        }
+        const dataSet = this.getDataSet(dataId);
+        if (options.renderMode === 'vtkVolume3d') {
+            if (!dataSet?.imageIds?.length) {
+                throw new Error(`[VolumeViewport3D] No registered volume dataset for ${dataId}`);
+            }
+            const volumeId = resolveViewportVolumeId(dataSet.volumeId ?? dataId);
+            const imageVolume = await createAndCacheVolume(volumeId, {
+                imageIds: dataSet.imageIds,
+            });
+            imageVolume.load();
+            return {
+                id: dataId,
+                type: 'image',
+                imageIds: imageVolume.imageIds || dataSet.imageIds,
+                imageVolume,
+                renderMode: 'vtkVolume3d',
+                volumeId,
+            };
+        }
+        const geometryId = dataSet?.geometryId || dataId;
+        const geometry = cache.getGeometry(geometryId) ||
+            (await loadAndCacheGeometry(geometryId, dataSet?.geometryLoadOptions));
+        return {
+            id: dataId,
+            type: 'geometry',
+            geometry,
+            geometryId,
+            renderMode: 'vtkGeometry3d',
+        };
+    }
+    getDataSet(dataId) {
+        const dataSet = getGenericViewportImageDataSet(dataId);
+        if (!isVolume3DRegisteredDataSet(dataSet)) {
+            return;
+        }
+        return dataSet;
+    }
+}
+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/Volume3DProjectionTypes.d.ts

@@ -0,0 +1,35 @@
+import { ViewportType } from '../../../enums';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot } from '../ViewportProjectionTypes';
+import type { Volume3DCamera, Volume3DViewportRenderContext } from './viewport3DTypes';
+export declare const VOLUME3D_PROJECTION_ID = "volume3d";
+export type Volume3DResolvedViewLike = {
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    toICamera(): ICamera;
+};
+export type Volume3DProjectionViewport = {
+    type: ViewportType | string;
+    canvas?: HTMLCanvasElement;
+    element?: HTMLDivElement;
+    getFrameOfReferenceUID?(): string | undefined;
+    getResolvedView?(): Volume3DResolvedViewLike;
+    getViewState?(): Volume3DCamera & ICamera;
+};
+export type Volume3DRenderTarget = Pick<Volume3DViewportRenderContext, 'vtk'>;
+export interface Volume3DProjectionPresentation extends ProjectionPresentation {
+    camera: Volume3DCamera & ICamera;
+}
+export interface Volume3DProjectionSnapshot extends ProjectionSnapshot<Volume3DCamera, Volume3DProjectionPresentation> {
+    canvasHeight: number;
+    canvasWidth: number;
+    resolvedView?: Volume3DResolvedViewLike;
+}
+export interface Volume3DProjectionRequest extends ProjectionRequest<Volume3DProjectionViewport> {
+    camera?: Volume3DCamera & ICamera;
+    canvasHeight?: number;
+    canvasWidth?: number;
+    frameOfReferenceUID?: string;
+    resolvedView?: Volume3DResolvedViewLike;
+}

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

@@ -0,0 +1,2 @@
+import { ViewportType } from '../../../enums';
+export const VOLUME3D_PROJECTION_ID = 'volume3d';

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

@@ -0,0 +1,4 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import type { RenderPathDefinition } from '../ViewportArchitectureTypes';
+export declare function createDefaultVolume3DRenderPaths(): RenderPathDefinition[];
+export declare function createVolume3DRenderPathResolver(paths?: ReadonlyArray<RenderPathDefinition>): DefaultRenderPathResolver;

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

@@ -0,0 +1,9 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import { VtkGeometry3DPath } from './VtkGeometry3DRenderPath';
+import { VtkVolume3DPath } from './VtkVolume3DRenderPath';
+export function createDefaultVolume3DRenderPaths() {
+    return [new VtkVolume3DPath(), new VtkGeometry3DPath()];
+}
+export function createVolume3DRenderPathResolver(paths = createDefaultVolume3DRenderPaths()) {
+    return new DefaultRenderPathResolver(paths);
+}

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

@@ -0,0 +1,18 @@
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import ResolvedViewportView from '../ResolvedViewportView';
+import type { Volume3DCamera } from './viewport3DTypes';
+type Volume3DResolvedViewState = {
+    camera: Volume3DCamera & ICamera;
+    canvas: HTMLCanvasElement;
+    frameOfReferenceUID?: string;
+    renderer: vtkRenderer;
+};
+declare class Volume3DResolvedView extends ResolvedViewportView<Volume3DResolvedViewState> {
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    protected buildICamera(): ICamera;
+}
+export type { Volume3DResolvedViewState };
+export default Volume3DResolvedView;

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

@@ -0,0 +1,42 @@
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
+import ResolvedViewportView from '../ResolvedViewportView';
+class Volume3DResolvedView extends ResolvedViewportView {
+    canvasToWorld(canvasPos) {
+        return canvasToWorldContextPool({
+            canvas: this.state.canvas,
+            canvasPos,
+            renderer: this.state.renderer,
+        });
+    }
+    worldToCanvas(worldPos) {
+        return worldToCanvasContextPool({
+            canvas: this.state.canvas,
+            renderer: this.state.renderer,
+            worldPos,
+        });
+    }
+    getFrameOfReferenceUID() {
+        return this.state.frameOfReferenceUID;
+    }
+    buildICamera() {
+        return {
+            ...this.state.camera,
+            clippingRange: this.state.camera.clippingRange
+                ? [...this.state.camera.clippingRange]
+                : this.state.camera.clippingRange,
+            focalPoint: this.state.camera.focalPoint
+                ? [...this.state.camera.focalPoint]
+                : this.state.camera.focalPoint,
+            position: this.state.camera.position
+                ? [...this.state.camera.position]
+                : this.state.camera.position,
+            viewPlaneNormal: this.state.camera.viewPlaneNormal
+                ? [...this.state.camera.viewPlaneNormal]
+                : this.state.camera.viewPlaneNormal,
+            viewUp: this.state.camera.viewUp
+                ? [...this.state.camera.viewUp]
+                : this.state.camera.viewUp,
+        };
+    }
+}
+export default Volume3DResolvedView;

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

@@ -0,0 +1,39 @@
+import type { ActorEntry, ICamera, IVolumeInput, VolumeViewportProperties } from '../../../types';
+import VolumeViewport3D from './viewport3D';
+import type { Volume3DCamera } from './viewport3DTypes';
+declare class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
+    private readonly managedDataIds;
+    private readonly volumeDataIds;
+    private readonly legacyProperties;
+    private readonly defaultLegacyProperties;
+    getCamera(): Volume3DCamera & ICamera;
+    setCamera(cameraPatch: Partial<Volume3DCamera>): void;
+    getViewPresentation(): {
+        camera: Volume3DCamera & ICamera;
+    } | undefined;
+    setViewPresentation(viewPresentation?: {
+        camera?: Partial<Volume3DCamera>;
+    } | Partial<Volume3DCamera>): void;
+    resetCamera(): boolean;
+    resetCameraForResize(): boolean;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setProperties(properties?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
+    getProperties(volumeId?: string): VolumeViewportProperties;
+    resetProperties(volumeId?: string): void;
+    setSampleDistanceMultiplier(multiplier: number): void;
+    removeData(dataId: string): void;
+    getActors(): ActorEntry[];
+    getDefaultActor(): ActorEntry | undefined;
+    private mountVolumes;
+    private buildActorEntries;
+    private applyPresetToBinding;
+    private getBindingActor;
+    private resolveTargetDataId;
+    private resolveVolumeIdForDataId;
+    private removeBindingsExcept;
+    private getLegacyVolumeDataId;
+    private forgetData;
+    protected onDestroy(): void;
+}
+export default VolumeViewport3DLegacyAdapter;

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

@@ -0,0 +1,296 @@
+import cache from '../../../cache/cache';
+import { VIEWPORT_PRESETS } from '../../../constants';
+import { Events } from '../../../enums';
+import applyPreset from '../../../utilities/applyPreset';
+import triggerEvent from '../../../utilities/triggerEvent';
+import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import { viewportProjection } from '../viewportProjection';
+import VolumeViewport3D from './viewport3D';
+class VolumeViewport3DLegacyAdapter extends VolumeViewport3D {
+    constructor() {
+        super(...arguments);
+        this.managedDataIds = new Set();
+        this.volumeDataIds = new Map();
+        this.legacyProperties = new Map();
+        this.defaultLegacyProperties = new Map();
+    }
+    getCamera() {
+        return this.getViewState();
+    }
+    setCamera(cameraPatch) {
+        this.setViewState(cameraPatch);
+    }
+    getViewPresentation() {
+        return viewportProjection.getPresentation(this);
+    }
+    setViewPresentation(viewPresentation) {
+        if (!viewPresentation) {
+            return;
+        }
+        const presentation = isVolume3DViewPresentation(viewPresentation)
+            ? viewPresentation
+            : { camera: viewPresentation };
+        const nextCamera = viewportProjection.withPresentation(this, presentation);
+        if (nextCamera) {
+            this.setViewState(nextCamera);
+        }
+    }
+    resetCamera() {
+        return this.resetViewState();
+    }
+    resetCameraForResize() {
+        return this.resetViewStateForResize();
+    }
+    async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
+        await this.mountVolumes(volumeInputArray, true, suppressEvents);
+        if (immediate) {
+            this.render();
+        }
+    }
+    async addVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
+        await this.mountVolumes(volumeInputArray, false, suppressEvents);
+        if (immediate) {
+            this.render();
+        }
+    }
+    setProperties(properties = {}, volumeId, suppressEvents = false) {
+        const targetDataId = this.resolveTargetDataId(volumeId);
+        if (!targetDataId) {
+            return;
+        }
+        const nextProperties = {
+            ...(this.legacyProperties.get(targetDataId) || {}),
+            ...properties,
+        };
+        if (!this.defaultLegacyProperties.has(targetDataId)) {
+            this.defaultLegacyProperties.set(targetDataId, { ...properties });
+        }
+        this.legacyProperties.set(targetDataId, nextProperties);
+        const presentationPatch = {};
+        if (properties.voiRange !== undefined) {
+            presentationPatch.voiRange = properties.voiRange;
+        }
+        if (properties.invert !== undefined) {
+            presentationPatch.invert = properties.invert;
+        }
+        if (properties.interpolationType !== undefined) {
+            presentationPatch.interpolationType = properties.interpolationType;
+        }
+        if (properties.sampleDistanceMultiplier !== undefined) {
+            presentationPatch.sampleDistanceMultiplier =
+                properties.sampleDistanceMultiplier;
+        }
+        if (Object.keys(presentationPatch).length) {
+            this.setDisplaySetPresentation(targetDataId, presentationPatch);
+        }
+        if (properties.preset !== undefined) {
+            this.applyPresetToBinding(targetDataId, properties.preset, volumeId, suppressEvents);
+        }
+        this.render();
+    }
+    getProperties(volumeId) {
+        const targetDataId = this.resolveTargetDataId(volumeId);
+        if (!targetDataId) {
+            return {};
+        }
+        return { ...(this.legacyProperties.get(targetDataId) || {}) };
+    }
+    resetProperties(volumeId) {
+        const targetDataId = this.resolveTargetDataId(volumeId);
+        if (!targetDataId) {
+            return;
+        }
+        const defaults = this.defaultLegacyProperties.get(targetDataId) || {};
+        this.legacyProperties.set(targetDataId, { ...defaults });
+        this.setDisplaySetPresentation(targetDataId, {
+            voiRange: defaults.voiRange,
+            invert: defaults.invert,
+            interpolationType: defaults.interpolationType,
+            sampleDistanceMultiplier: defaults.sampleDistanceMultiplier,
+        });
+        if (defaults.preset !== undefined) {
+            this.applyPresetToBinding(targetDataId, defaults.preset, volumeId, false);
+        }
+        this.render();
+    }
+    setSampleDistanceMultiplier(multiplier) {
+        this.setProperties({ sampleDistanceMultiplier: multiplier });
+    }
+    removeData(dataId) {
+        super.removeData(dataId);
+        this.forgetData(dataId);
+    }
+    getActors() {
+        return super.getActors();
+    }
+    getDefaultActor() {
+        return super.getDefaultActor();
+    }
+    async mountVolumes(volumeInputArray, replaceExisting, suppressEvents) {
+        if (!volumeInputArray.length) {
+            return;
+        }
+        const dataIds = [];
+        try {
+            for (const volumeInput of volumeInputArray) {
+                const cachedVolume = cache.getVolume(volumeInput.volumeId);
+                if (!cachedVolume) {
+                    throw new Error(`imageVolume with id: ${volumeInput.volumeId} does not exist, you need to create/allocate the volume first`);
+                }
+                const dataId = this.getLegacyVolumeDataId(volumeInput.volumeId);
+                const dataSet = {
+                    imageIds: cachedVolume.imageIds,
+                    volumeId: volumeInput.volumeId,
+                };
+                genericViewportDataSetMetadataProvider.add(dataId, dataSet);
+                this.managedDataIds.add(dataId);
+                this.volumeDataIds.set(volumeInput.volumeId, dataId);
+                dataIds.push(dataId);
+            }
+            if (replaceExisting) {
+                this.removeBindingsExcept(new Set(dataIds));
+            }
+            await this.setDisplaySets(...dataIds.map((dataId) => ({
+                displaySetId: dataId,
+                options: { renderMode: 'vtkVolume3d' },
+            })));
+            volumeInputArray.forEach((volumeInput, index) => {
+                const dataId = dataIds[index];
+                if (volumeInput.visibility !== undefined) {
+                    this.setDisplaySetPresentation(dataId, {
+                        visible: volumeInput.visibility,
+                    });
+                }
+                if (volumeInput.callback) {
+                    const actor = this.getBindingActor(dataId);
+                    if (actor) {
+                        volumeInput.callback({
+                            volumeActor: actor,
+                            volumeId: volumeInput.volumeId,
+                        });
+                    }
+                }
+            });
+            if (!suppressEvents) {
+                triggerEvent(this.element, Events.VOLUME_VIEWPORT_NEW_VOLUME, {
+                    viewportId: this.id,
+                    volumeActors: this.buildActorEntries(volumeInputArray, dataIds),
+                });
+            }
+        }
+        catch (error) {
+            dataIds.forEach((dataId) => {
+                this.forgetData(dataId);
+            });
+            throw error;
+        }
+    }
+    buildActorEntries(volumeInputArray, dataIds) {
+        return volumeInputArray.flatMap((volumeInput, index) => {
+            const actor = this.getBindingActor(dataIds[index]);
+            if (!actor) {
+                return [];
+            }
+            const { actorUID, slabThickness, volumeId, ...rest } = volumeInput;
+            return [
+                {
+                    uid: actorUID || volumeId,
+                    actor: actor,
+                    slabThickness,
+                    referencedId: volumeId,
+                    ...rest,
+                },
+            ];
+        });
+    }
+    applyPresetToBinding(dataId, presetNameOrObj, requestedVolumeId, suppressEvents) {
+        const preset = typeof presetNameOrObj === 'string'
+            ? VIEWPORT_PRESETS.find((entry) => entry.name === presetNameOrObj)
+            : presetNameOrObj;
+        if (!preset) {
+            return;
+        }
+        const actor = this.getBindingActor(dataId);
+        if (!actor) {
+            return;
+        }
+        applyPreset(actor, preset);
+        if (!suppressEvents) {
+            triggerEvent(this.element, Events.PRESET_MODIFIED, {
+                viewportId: this.id,
+                volumeId: requestedVolumeId ?? this.resolveVolumeIdForDataId(dataId),
+                actor,
+                presetName: preset.name,
+            });
+        }
+    }
+    getBindingActor(dataId) {
+        const binding = this.getBinding(dataId);
+        if (!binding) {
+            return;
+        }
+        const rendering = binding.rendering;
+        return rendering?.actor;
+    }
+    resolveTargetDataId(volumeId) {
+        if (volumeId) {
+            const mapped = this.volumeDataIds.get(volumeId);
+            if (mapped) {
+                return mapped;
+            }
+            for (const [dataId, binding] of this.bindings.entries()) {
+                const rendering = binding.rendering;
+                if (rendering?.imageVolume?.volumeId === volumeId) {
+                    return dataId;
+                }
+            }
+        }
+        return this.bindings.keys().next().value;
+    }
+    resolveVolumeIdForDataId(dataId) {
+        for (const [volumeId, mappedDataId] of this.volumeDataIds.entries()) {
+            if (mappedDataId === dataId) {
+                return volumeId;
+            }
+        }
+    }
+    removeBindingsExcept(keepDataIds) {
+        for (const dataId of Array.from(this.bindings.keys())) {
+            if (!keepDataIds.has(dataId)) {
+                this.removeData(dataId);
+            }
+        }
+    }
+    getLegacyVolumeDataId(volumeId) {
+        return `__volume3d__:${this.id}:volume:${volumeId}`;
+    }
+    forgetData(dataId) {
+        if (!this.managedDataIds.delete(dataId)) {
+            return;
+        }
+        genericViewportDataSetMetadataProvider.remove(dataId);
+        this.legacyProperties.delete(dataId);
+        this.defaultLegacyProperties.delete(dataId);
+        for (const [volumeId, mappedDataId] of this.volumeDataIds.entries()) {
+            if (mappedDataId === dataId) {
+                this.volumeDataIds.delete(volumeId);
+            }
+        }
+    }
+    onDestroy() {
+        for (const dataId of Array.from(this.managedDataIds)) {
+            genericViewportDataSetMetadataProvider.remove(dataId);
+        }
+        this.managedDataIds.clear();
+        this.volumeDataIds.clear();
+        this.legacyProperties.clear();
+        this.defaultLegacyProperties.clear();
+        super.onDestroy();
+    }
+}
+export default VolumeViewport3DLegacyAdapter;
+function isVolume3DViewPresentation(viewPresentation) {
+    return (Boolean(viewPresentation) &&
+        typeof viewPresentation === 'object' &&
+        'camera' in viewPresentation);
+}

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

@@ -0,0 +1,22 @@
+import '@kitware/vtk.js/Rendering/Profiles/Geometry';
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { Volume3DDataPresentation, Volume3DViewportRenderContext, Volume3DVtkGeometryAdapterContext } from './viewport3DTypes';
+export declare class VtkGeometry3DRenderPath implements RenderPath<Volume3DVtkGeometryAdapterContext> {
+    addData(ctx: Volume3DVtkGeometryAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<Volume3DDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private canvasToWorld;
+    private worldToCanvas;
+    private getFrameOfReferenceUID;
+    private render;
+    private resize;
+    private removeData;
+}
+export declare class VtkGeometry3DPath implements RenderPathDefinition<Volume3DViewportRenderContext, Volume3DVtkGeometryAdapterContext> {
+    readonly id = "volume3d:vtk-geometry";
+    readonly type = ViewportType.VOLUME_3D_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): VtkGeometry3DRenderPath;
+    selectContext(rootContext: Volume3DViewportRenderContext): Volume3DVtkGeometryAdapterContext;
+}