@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkImageMapperRenderPath.js

@@ -0,0 +1,259 @@
+import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import { buildPlanarActorEntry } from './buildPlanarActorEntry';
+import uuidv4 from '../../../utilities/uuidv4';
+import { InterpolationType, MetadataModules, ViewportType, } from '../../../enums';
+import { loadAndCacheImage } from '../../../loaders/imageLoader';
+import * as metaData from '../../../metaData';
+import { ActorRenderMode } from '../../../types';
+import { applyPlanarImagePresentation, createVTKImageDataFromImage, getDefaultImageVOIRange, } from '../../helpers/planarImageRendering';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms';
+import { buildPlanarImageData } from './CpuImageSliceRenderPath';
+import { triggerPlanarNewImage } from './planarImageEvents';
+import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera';
+import { resolvePlanarRenderPathCurrentImageIdIndex, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection';
+export class VtkImageMapperRenderPath {
+    async addData(ctx, data, options) {
+        const payload = data;
+        if (!payload.image) {
+            throw new Error('[PlanarViewport] VTK image rendering requires an image');
+        }
+        const mapper = vtkImageMapper.newInstance();
+        const actor = vtkImageSlice.newInstance();
+        const imageData = payload.imageData ?? createVTKImageDataFromImage(payload.image);
+        ctx.display.activateRenderMode(ActorRenderMode.VTK_IMAGE);
+        mapper.setInputData(imageData);
+        actor.setMapper(mapper);
+        ctx.vtk.renderer.addActor(actor);
+        const rendering = {
+            renderMode: ActorRenderMode.VTK_IMAGE,
+            actorEntryUID: uuidv4(),
+            actor,
+            currentImage: payload.image,
+            mapper,
+            imageData,
+            useWorldCoordinateImageData: payload.useWorldCoordinateImageData,
+            currentImageIdIndex: payload.initialImageIdIndex,
+            defaultVOIRange: getDefaultImageVOIRange(payload.image),
+            dataPresentation: undefined,
+            loadRequestId: 0,
+        };
+        triggerPlanarNewImage(ctx, {
+            image: payload.image,
+            imageIdIndex: payload.initialImageIdIndex,
+        });
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(ctx, rendering, data.id, camera, payload.imageIds);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(rendering);
+            },
+            getActorEntry: (data) => {
+                return buildPlanarActorEntry(data, {
+                    actor: rendering.actor,
+                    mapper: rendering.mapper,
+                    renderMode: ActorRenderMode.VTK_IMAGE,
+                    uid: rendering.actorEntryUID,
+                    referencedIdFallback: rendering.currentImage.imageId,
+                });
+            },
+            getImageData: () => {
+                return this.getImageData(rendering);
+            },
+            resize: () => {
+                this.resize(ctx, rendering, data.id);
+            },
+            removeData: () => {
+                this.removeData(ctx, rendering);
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        const dataPresentation = props;
+        rendering.dataPresentation = dataPresentation;
+        applyPlanarImagePresentation({
+            actor: rendering.actor,
+            defaultVOIRange: rendering.defaultVOIRange,
+            props: {
+                interpolationType: InterpolationType.LINEAR,
+                ...dataPresentation,
+            },
+        });
+    }
+    applyViewState(ctx, rendering, dataId, camera, imageIds) {
+        const planarCamera = camera;
+        ctx.display.activateRenderMode(ActorRenderMode.VTK_IMAGE);
+        if (rendering.useWorldCoordinateImageData) {
+            return;
+        }
+        const projection = resolvePlanarRenderPathProjection({
+            ctx,
+            dataId,
+            imageIds,
+            rendering,
+            viewState: planarCamera,
+        });
+        const nextImageIdIndex = resolvePlanarRenderPathCurrentImageIdIndex({
+            projection,
+            rendering,
+            viewState: planarCamera,
+        });
+        if (projection) {
+            applyPlanarImageActorTransforms(ctx, rendering, projection.resolvedICamera);
+            if (projection.isSourceBinding) {
+                applyPlanarICameraToRenderer({
+                    renderer: ctx.vtk.renderer,
+                    activeSourceICamera: projection.resolvedICamera,
+                });
+            }
+        }
+        const dedupTarget = rendering.lastRequestedImageIdIndex ?? rendering.currentImageIdIndex;
+        if (nextImageIdIndex === dedupTarget) {
+            return;
+        }
+        if (nextImageIdIndex < 0 || nextImageIdIndex >= imageIds.length) {
+            return;
+        }
+        rendering.lastRequestedImageIdIndex = nextImageIdIndex;
+        const requestId = ++rendering.loadRequestId;
+        void loadAndCacheImage(imageIds[nextImageIdIndex]).then((image) => {
+            if (requestId !== rendering.loadRequestId) {
+                return;
+            }
+            void updateRenderedImage({
+                ctx,
+                dataId,
+                image,
+                rendering,
+                imageIdIndex: nextImageIdIndex,
+                dataPresentation: rendering.dataPresentation,
+            });
+        });
+    }
+    canvasToWorld(ctx, canvasPos) {
+        return canvasToWorldContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            canvasPos,
+        });
+    }
+    worldToCanvas(ctx, worldPos) {
+        return worldToCanvasContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            worldPos,
+        });
+    }
+    getFrameOfReferenceUID(rendering) {
+        const imageId = rendering.currentImage.imageId;
+        const imagePlaneModule = imageId
+            ? metaData.get(MetadataModules.IMAGE_PLANE, imageId)
+            : undefined;
+        return imagePlaneModule?.frameOfReferenceUID;
+    }
+    getImageData(rendering) {
+        return buildPlanarImageData(rendering.currentImage, this.getFrameOfReferenceUID(rendering));
+    }
+    removeData(ctx, rendering) {
+        const { actor } = rendering;
+        ctx.vtk.renderer.removeActor(actor);
+    }
+    resize(ctx, rendering, dataId) {
+        if (rendering.useWorldCoordinateImageData) {
+            ctx.display.requestRender();
+            return;
+        }
+        const camera = ctx.viewport.getViewState();
+        const projection = resolvePlanarRenderPathProjection({
+            ctx,
+            dataId,
+            rendering,
+            viewState: camera,
+        });
+        if (projection) {
+            applyPlanarImageActorTransforms(ctx, rendering, projection.resolvedICamera);
+            if (projection.isSourceBinding) {
+                applyPlanarICameraToRenderer({
+                    renderer: ctx.vtk.renderer,
+                    activeSourceICamera: projection.resolvedICamera,
+                });
+            }
+        }
+        ctx.display.requestRender();
+    }
+}
+export class VtkImageMapperPath {
+    constructor() {
+        this.id = 'planar:vtk-image-mapper';
+        this.type = ViewportType.PLANAR_NEXT;
+    }
+    matches(data, options) {
+        return (data.type === 'image' && options.renderMode === ActorRenderMode.VTK_IMAGE);
+    }
+    createRenderPath() {
+        return new VtkImageMapperRenderPath();
+    }
+    selectContext(rootContext) {
+        return {
+            viewportId: rootContext.viewportId,
+            renderingEngineId: rootContext.renderingEngineId,
+            type: rootContext.type,
+            viewport: rootContext.viewport,
+            renderPath: rootContext.renderPath,
+            view: rootContext.view,
+            display: rootContext.display,
+            vtk: rootContext.vtk,
+        };
+    }
+}
+async function updateRenderedImage(args) {
+    const { ctx, dataId, image, rendering, imageIdIndex, dataPresentation } = args;
+    const camera = ctx.viewport.getViewState();
+    const { actor, mapper } = rendering;
+    const imageData = createVTKImageDataFromImage(image);
+    mapper.setInputData(imageData);
+    rendering.currentImage = image;
+    rendering.imageData = imageData;
+    rendering.currentImageIdIndex = imageIdIndex;
+    rendering.defaultVOIRange = getDefaultImageVOIRange(image);
+    ctx.viewport.invalidateResolvedView();
+    if (imageData.getPointData().getScalars().getNumberOfComponents() > 1) {
+        actor.getProperty().setIndependentComponents(false);
+    }
+    applyPlanarImagePresentation({
+        actor,
+        defaultVOIRange: rendering.defaultVOIRange,
+        props: {
+            interpolationType: dataPresentation?.interpolationType ?? InterpolationType.LINEAR,
+            ...dataPresentation,
+        },
+    });
+    const projection = resolvePlanarRenderPathProjection({
+        ctx,
+        dataId,
+        rendering,
+        viewState: camera,
+    });
+    if (projection) {
+        applyPlanarImageActorTransforms(ctx, rendering, projection.resolvedICamera);
+        if (projection.isSourceBinding) {
+            applyPlanarICameraToRenderer({
+                renderer: ctx.vtk.renderer,
+                activeSourceICamera: projection.resolvedICamera,
+            });
+        }
+    }
+    triggerPlanarNewImage(ctx, { image, imageIdIndex });
+    ctx.display.requestRender();
+}
+function applyPlanarImageActorTransforms(ctx, rendering, activeSourceICamera) {
+    applyPlanarICameraToActor({
+        actor: rendering.actor,
+        activeSourceICamera,
+    });
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkVolumeSliceRenderPath.d.ts

@@ -0,0 +1,23 @@
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkVolumeAdapterContext } from './PlanarViewportTypes';
+export declare class VtkVolumeSliceRenderPath implements RenderPath<PlanarVtkVolumeAdapterContext> {
+    addData(ctx: PlanarVtkVolumeAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<PlanarDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private syncRenderCamera;
+    private canvasToWorld;
+    private worldToCanvas;
+    private getFrameOfReferenceUID;
+    private getImageData;
+    private render;
+    private resize;
+    private removeData;
+}
+export declare class VtkVolumeSlicePath implements RenderPathDefinition<PlanarViewportRenderContext, PlanarVtkVolumeAdapterContext> {
+    readonly id = "planar:vtk-volume-slice";
+    readonly type = ViewportType.PLANAR_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): VtkVolumeSliceRenderPath;
+    selectContext(rootContext: PlanarViewportRenderContext): PlanarVtkVolumeAdapterContext;
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkVolumeSliceRenderPath.js

@@ -0,0 +1,289 @@
+import vtkPlaneFactory from '@kitware/vtk.js/Common/DataModel/Plane';
+import { buildPlanarActorEntry } from './buildPlanarActorEntry';
+import uuidv4 from '../../../utilities/uuidv4';
+import { Events, ViewportType } from '../../../enums';
+import eventTarget from '../../../eventTarget';
+import createVolumeSliceActor from '../../helpers/createVolumeSliceActor';
+import { ActorRenderMode } from '../../../types';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms';
+import { triggerPlanarVolumeNewImage } from './planarImageEvents';
+import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera';
+import { getPlanarRenderPathActiveSourceICamera, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection';
+import { applyPlanarVolumePresentation } from './planarVolumePresentation';
+const SLICE_OVERLAY_DEPTH_EPSILON = 1e-4;
+export class VtkVolumeSliceRenderPath {
+    async addData(ctx, data, options) {
+        const payload = data;
+        const imageVolume = payload.imageVolume;
+        const shouldInvalidateFullTextureOnVolumeModified = options.role === 'overlay' && payload.reference?.kind === 'segmentation';
+        if (!imageVolume) {
+            throw new Error('[PlanarViewport] Volume rendering requires a prepared image volume');
+        }
+        const { actor } = await createVolumeSliceActor({
+            volumeId: payload.volumeId,
+        }, ctx.viewport.element, ctx.viewportId, true);
+        const mapper = actor.getMapper();
+        ctx.display.activateRenderMode(ActorRenderMode.VTK_VOLUME_SLICE);
+        ctx.vtk.renderer.addActor(actor);
+        const transferFunction = actor.getProperty().getRGBTransferFunction(0);
+        const defaultRange = transferFunction?.getRange?.();
+        const rendering = {
+            renderMode: ActorRenderMode.VTK_VOLUME_SLICE,
+            actorEntryUID: uuidv4(),
+            actor,
+            overlayOrder: getImageSliceOverlayOrder(ctx.vtk.renderer, actor),
+            imageVolume,
+            imageIds: payload.imageIds,
+            acquisitionOrientation: payload.acquisitionOrientation,
+            mapper,
+            currentImageIdIndex: payload.initialImageIdIndex,
+            maxImageIdIndex: payload.imageIds.length - 1,
+            defaultVOIRange: defaultRange
+                ? { lower: defaultRange[0], upper: defaultRange[1] }
+                : undefined,
+            dataPresentation: undefined,
+            removeStreamingSubscriptions: subscribeToVolumeEvents(payload.volumeId, (eventType) => {
+                if (eventType === Events.IMAGE_VOLUME_MODIFIED) {
+                    if (shouldInvalidateFullTextureOnVolumeModified) {
+                        imageVolume.vtkOpenGLTexture?.modified?.();
+                    }
+                    mapper.modified();
+                }
+                ctx.display.requestRender();
+            }),
+        };
+        imageVolume.load(() => {
+            ctx.display.requestRender();
+        });
+        triggerPlanarVolumeNewImage(ctx, {
+            camera: ctx.viewport.getViewState(),
+            acquisitionOrientation: rendering.acquisitionOrientation,
+            imageIds: rendering.imageIds,
+            imageIdIndex: rendering.currentImageIdIndex,
+        });
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(ctx, rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(ctx, rendering, data.id, camera);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(rendering);
+            },
+            getActorEntry: (data) => {
+                const planarData = data;
+                return buildPlanarActorEntry(planarData, {
+                    actor: rendering.actor,
+                    mapper: rendering.mapper,
+                    renderMode: ActorRenderMode.VTK_VOLUME_SLICE,
+                    uid: rendering.actorEntryUID,
+                    referencedIdFallback: planarData.volumeId,
+                });
+            },
+            getImageData: () => {
+                return this.getImageData(rendering);
+            },
+            render: () => {
+                this.render(ctx);
+            },
+            resize: () => {
+                this.resize(ctx, rendering, data.id);
+            },
+            removeData: () => {
+                this.removeData(ctx, rendering);
+            },
+        };
+    }
+    updateDataPresentation(ctx, rendering, props) {
+        rendering.dataPresentation = props;
+        applyPlanarVolumePresentation({
+            actor: rendering.actor,
+            defaultVOIRange: rendering.defaultVOIRange,
+            mapper: rendering.mapper,
+            props: rendering.dataPresentation,
+        });
+        const activeSourceICamera = getPlanarRenderPathActiveSourceICamera(ctx);
+        updateVolumeSlicePlane(rendering.mapper, activeSourceICamera);
+        applyPlanarICameraToActor({
+            actor: rendering.actor,
+            activeSourceICamera,
+        });
+        updateVolumeSliceActorDepthOffset(rendering.actor, activeSourceICamera, rendering.overlayOrder);
+        ctx.vtk.renderer.resetCameraClippingRange();
+    }
+    applyViewState(ctx, rendering, dataId, cameraInput) {
+        const camera = cameraInput;
+        ctx.display.activateRenderMode(ActorRenderMode.VTK_VOLUME_SLICE);
+        this.syncRenderCamera(ctx, rendering, dataId, camera, true);
+    }
+    syncRenderCamera(ctx, rendering, dataId, camera, triggerImageEvent) {
+        const projection = resolvePlanarRenderPathProjection({
+            ctx,
+            dataId,
+            rendering,
+            viewState: camera,
+        });
+        if (!projection) {
+            return;
+        }
+        if (projection.isSourceBinding) {
+            applyPlanarICameraToRenderer({
+                renderer: ctx.vtk.renderer,
+                activeSourceICamera: projection.resolvedICamera,
+            });
+        }
+        applyPlanarICameraToActor({
+            actor: rendering.actor,
+            activeSourceICamera: projection.activeSourceICamera,
+        });
+        const imageIdIndexChanged = projection.currentImageIdIndex !== rendering.currentImageIdIndex;
+        const maxImageIdIndexChanged = projection.maxImageIdIndex !== rendering.maxImageIdIndex;
+        rendering.currentImageIdIndex = projection.currentImageIdIndex;
+        rendering.maxImageIdIndex = projection.maxImageIdIndex;
+        if (imageIdIndexChanged || maxImageIdIndexChanged) {
+            ctx.viewport.invalidateResolvedView();
+        }
+        updateVolumeSlicePlane(rendering.mapper, projection.activeSourceICamera);
+        updateVolumeSliceActorDepthOffset(rendering.actor, projection.activeSourceICamera, rendering.overlayOrder);
+        ctx.vtk.renderer.resetCameraClippingRange();
+        if (triggerImageEvent && imageIdIndexChanged) {
+            triggerPlanarVolumeNewImage(ctx, {
+                camera,
+                acquisitionOrientation: rendering.acquisitionOrientation,
+                imageIds: rendering.imageIds,
+                imageIdIndex: rendering.currentImageIdIndex,
+            });
+        }
+    }
+    canvasToWorld(ctx, canvasPos) {
+        return canvasToWorldContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            canvasPos,
+        });
+    }
+    worldToCanvas(ctx, worldPos) {
+        return worldToCanvasContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            worldPos,
+        });
+    }
+    getFrameOfReferenceUID(rendering) {
+        return rendering.imageVolume.metadata?.FrameOfReferenceUID;
+    }
+    getImageData(rendering) {
+        return buildPlanarVolumeImageData(rendering.imageVolume);
+    }
+    render(ctx) {
+        ctx.display.requestRender();
+    }
+    resize(ctx, rendering, dataId) {
+        const camera = ctx.viewport.getViewState();
+        this.syncRenderCamera(ctx, rendering, dataId, camera, false);
+        ctx.display.requestRender();
+    }
+    removeData(ctx, rendering) {
+        const { actor, removeStreamingSubscriptions } = rendering;
+        removeStreamingSubscriptions?.();
+        ctx.vtk.renderer.removeActor(actor);
+    }
+}
+export class VtkVolumeSlicePath {
+    constructor() {
+        this.id = 'planar:vtk-volume-slice';
+        this.type = ViewportType.PLANAR_NEXT;
+    }
+    matches(data, options) {
+        return (data.type === 'image' &&
+            options.renderMode === ActorRenderMode.VTK_VOLUME_SLICE);
+    }
+    createRenderPath() {
+        return new VtkVolumeSliceRenderPath();
+    }
+    selectContext(rootContext) {
+        return {
+            viewportId: rootContext.viewportId,
+            renderingEngineId: rootContext.renderingEngineId,
+            type: rootContext.type,
+            viewport: rootContext.viewport,
+            renderPath: rootContext.renderPath,
+            view: rootContext.view,
+            display: rootContext.display,
+            vtk: rootContext.vtk,
+        };
+    }
+}
+function subscribeToVolumeEvents(volumeId, onProgress) {
+    const handleProgress = (evt) => {
+        const detail = evt.detail;
+        if (detail?.volumeId !== volumeId) {
+            return;
+        }
+        onProgress(evt.type);
+    };
+    eventTarget.addEventListener(Events.IMAGE_VOLUME_MODIFIED, handleProgress);
+    eventTarget.addEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, handleProgress);
+    return () => {
+        eventTarget.removeEventListener(Events.IMAGE_VOLUME_MODIFIED, handleProgress);
+        eventTarget.removeEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, handleProgress);
+    };
+}
+function ensureSlicePlane(mapper) {
+    const existingSlicePlane = mapper.getSlicePlane?.();
+    if (existingSlicePlane) {
+        return existingSlicePlane;
+    }
+    const slicePlane = vtkPlaneFactory.newInstance();
+    mapper.setSlicePlane(slicePlane);
+    return slicePlane;
+}
+function updateVolumeSlicePlane(mapper, activeSourceICamera) {
+    if (!activeSourceICamera?.focalPoint ||
+        !activeSourceICamera.viewPlaneNormal) {
+        return;
+    }
+    const slicePlane = ensureSlicePlane(mapper);
+    slicePlane.setOrigin(...activeSourceICamera.focalPoint);
+    slicePlane.setNormal(...activeSourceICamera.viewPlaneNormal);
+}
+function getImageSliceOverlayOrder(renderer, actor) {
+    const imageSliceActors = renderer
+        .getActors()
+        .filter((currentActor) => currentActor?.getClassName?.() === 'vtkImageSlice');
+    return Math.max(0, imageSliceActors.indexOf(actor));
+}
+function updateVolumeSliceActorDepthOffset(actor, activeSourceICamera, overlayOrder = 0) {
+    if (!activeSourceICamera?.viewPlaneNormal || overlayOrder <= 0) {
+        actor.setPosition(0, 0, 0);
+        return;
+    }
+    const [x, y, z] = activeSourceICamera.viewPlaneNormal;
+    const offset = overlayOrder * SLICE_OVERLAY_DEPTH_EPSILON;
+    actor.setPosition(x * offset, y * offset, z * offset);
+}
+function buildPlanarVolumeImageData(imageVolume) {
+    const vtkImageData = imageVolume.imageData;
+    if (!vtkImageData) {
+        return;
+    }
+    return {
+        dimensions: vtkImageData.getDimensions(),
+        spacing: vtkImageData.getSpacing(),
+        origin: vtkImageData.getOrigin(),
+        direction: vtkImageData.getDirection(),
+        imageData: vtkImageData,
+        metadata: {
+            Modality: imageVolume.metadata?.Modality,
+            FrameOfReferenceUID: imageVolume.metadata?.FrameOfReferenceUID,
+        },
+        get scalarData() {
+            return imageVolume.voxelManager?.getScalarData();
+        },
+        scaling: imageVolume.scaling,
+        hasPixelSpacing: imageVolume.hasPixelSpacing,
+        voxelManager: imageVolume.voxelManager,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/buildPlanarActorEntry.d.ts

@@ -0,0 +1,10 @@
+import type { ActorEntry } from '../../../types';
+import type { LoadedData } from '../ViewportArchitectureTypes';
+import type { PlanarPayload } from './PlanarViewportTypes';
+export declare function buildPlanarActorEntry(data: LoadedData<PlanarPayload>, source: {
+    actor: NonNullable<ActorEntry['actorMapper']>['actor'];
+    mapper?: NonNullable<ActorEntry['actorMapper']>['mapper'];
+    renderMode: NonNullable<ActorEntry['actorMapper']>['renderMode'];
+    uid: string;
+    referencedIdFallback?: string;
+}): ActorEntry;

package/dist/esm/RenderingEngine/GenericViewport/Planar/buildPlanarActorEntry.js

@@ -0,0 +1,54 @@
+export function buildPlanarActorEntry(data, source) {
+    const referenceFields = getActorEntryReferenceFields(data.reference, data.volumeId || source.referencedIdFallback);
+    const actor = source.actor;
+    const mapper = source.mapper ??
+        (typeof actor.getMapper === 'function'
+            ? actor.getMapper()
+            : undefined);
+    return {
+        uid: source.uid,
+        actor: actor,
+        actorMapper: {
+            actor,
+            mapper,
+            renderMode: source.renderMode,
+        },
+        ...referenceFields,
+    };
+}
+function getActorEntryReferenceFields(reference, fallbackReferencedId) {
+    if (!reference) {
+        return fallbackReferencedId ? { referencedId: fallbackReferencedId } : {};
+    }
+    if (reference.kind === 'segmentation') {
+        return {
+            reference,
+            referencedId: reference.labelmapId ??
+                reference.representationUID ??
+                reference.segmentationId,
+            ...(reference.representationUID
+                ? { representationUID: reference.representationUID }
+                : {}),
+        };
+    }
+    return {
+        reference,
+        referencedId: getReferenceId(reference),
+    };
+}
+function getReferenceId(reference) {
+    switch (reference.kind) {
+        case 'data':
+            return reference.dataId;
+        case 'image':
+            return reference.imageId;
+        case 'volume':
+            return reference.volumeId;
+        case 'geometry':
+            return reference.geometryId;
+        case 'segmentation':
+            return (reference.labelmapId ??
+                reference.representationUID ??
+                reference.segmentationId);
+    }
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/index.d.ts

@@ -0,0 +1,23 @@
+import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera } from './planarRenderCamera';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionAdapter';
+import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis } from './planarSliceBasis';
+export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver';
+export declare const planarProjection: {
+    adapter: import("..").ViewportProjectionAdapter<import("./PlanarViewportTypes").PlanarViewState, import("./PlanarViewportTypes").PlanarViewPresentation, import("./PlanarProjectionTypes").PlanarProjectionSnapshot>;
+    getSnapshot: typeof getPlanarProjectionSnapshot;
+    getZoom: typeof getPlanarProjectionZoom;
+    getScale: typeof getPlanarProjectionScale;
+    getPan: typeof getPlanarProjectionPan;
+    resolveICamera: typeof resolvePlanarICamera;
+    derivePresentation: typeof derivePlanarPresentation;
+    applyToRenderer: typeof applyPlanarICameraToRenderer;
+    createImageSliceBasis: typeof createPlanarImageSliceBasis;
+    createVolumeSliceBasis: typeof createPlanarVolumeSliceBasis;
+};
+export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './planarProjectionAdapter';
+export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView';
+export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection';
+export { default, default as PlanarViewport } from './PlanarViewport';
+export type { PlanarSliceBasis } from './planarSliceBasis';
+export type { PlanarViewState, PlanarDataPresentation, PlanarOrientation, PlanarPresentationProps, PlanarProperties, PlanarRenderMode, PlanarSetDataOptions, PlanarViewportInput, PlanarViewportInputOptions, PlanarDisplayArea, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarSliceState, PlanarResolvedICamera, } from './PlanarViewportTypes';

package/dist/esm/RenderingEngine/GenericViewport/Planar/index.js

@@ -0,0 +1,20 @@
+import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera, } from './planarRenderCamera';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, planarProjectionAdapter, } from './planarProjectionAdapter';
+import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis, } from './planarSliceBasis';
+export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver';
+export const planarProjection = {
+    adapter: planarProjectionAdapter,
+    getSnapshot: getPlanarProjectionSnapshot,
+    getZoom: getPlanarProjectionZoom,
+    getScale: getPlanarProjectionScale,
+    getPan: getPlanarProjectionPan,
+    resolveICamera: resolvePlanarICamera,
+    derivePresentation: derivePlanarPresentation,
+    applyToRenderer: applyPlanarICameraToRenderer,
+    createImageSliceBasis: createPlanarImageSliceBasis,
+    createVolumeSliceBasis: createPlanarVolumeSliceBasis,
+};
+export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView';
+export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection';
+export { default, default as PlanarViewport } from './PlanarViewport';