@cornerstonejs/core/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathProjection.js

Cornerstone3D Core

import { ActorRenderMode } from '../../../types/index.js';
import { canvasToWorldPlanarViewState, getCanvasCssDimensions, worldToCanvasPlanarViewState, } from './planarAdapterCoordinateTransforms.js';
import { resolvePlanarStackImageIdIndex, resolvePlanarViewportView, } from './PlanarResolvedView.js';
export { resolvePlanarStackImageIdIndex };
export function resolvePlanarRenderPathCurrentImageIdIndex(args) {
    const { projection, rendering, viewState } = args;
    if (projection) {
        return projection.currentImageIdIndex;
    }
    if (rendering.renderMode === ActorRenderMode.CPU_IMAGE ||
        rendering.renderMode === ActorRenderMode.VTK_IMAGE) {
        return resolvePlanarStackImageIdIndex({
            fallbackImageIdIndex: rendering.currentImageIdIndex,
            viewState,
        });
    }
    return rendering.currentImageIdIndex;
}
export function getPlanarRenderPathActiveSourceICamera(args) {
    const activeSourceICamera = args.view.activeSourceICamera;
    if (!activeSourceICamera?.focalPoint ||
        typeof activeSourceICamera.parallelScale !== 'number' ||
        !activeSourceICamera.viewPlaneNormal ||
        !activeSourceICamera.viewUp) {
        return;
    }
    return activeSourceICamera;
}
export function canvasToWorldPlanarRenderPathProjection(args) {
    const activeSourceICamera = getPlanarRenderPathActiveSourceICamera(args.ctx);
    if (!activeSourceICamera) {
        return [0, 0, 0];
    }
    const { canvasWidth, canvasHeight } = getCanvasCssDimensions(args.canvas);
    return canvasToWorldPlanarViewState({
        camera: activeSourceICamera,
        canvasWidth,
        canvasHeight,
        canvasPos: args.canvasPos,
    });
}
export function worldToCanvasPlanarRenderPathProjection(args) {
    const activeSourceICamera = getPlanarRenderPathActiveSourceICamera(args.ctx);
    if (!activeSourceICamera) {
        return [0, 0];
    }
    const { canvasWidth, canvasHeight } = getCanvasCssDimensions(args.canvas);
    return worldToCanvasPlanarViewState({
        camera: activeSourceICamera,
        canvasWidth,
        canvasHeight,
        worldPos: args.worldPos,
    });
}
export function resolvePlanarRenderPathProjection(args) {
    const { ctx, data, dataId, frameOfReferenceUID, imageIds, rendering, sliceIndex, viewState = {}, } = args;
    const resolvedView = resolvePlanarViewportView({
        viewState,
        data,
        frameOfReferenceUID,
        imageIds,
        rendering,
        renderContext: ctx,
        sliceIndex,
    });
    if (!resolvedView) {
        return;
    }
    const resolvedICamera = resolvedView.toICamera();
    const isSourceBinding = ctx.viewport.isCurrentDataId(dataId);
    if (isSourceBinding) {
        ctx.view.activeSourceICamera = resolvedICamera;
    }
    const activeSourceICamera = isSourceBinding
        ? resolvedICamera
        : getPlanarRenderPathActiveSourceICamera(ctx) || resolvedICamera;
    return {
        activeSourceICamera,
        currentImageIdIndex: resolvedView.state.currentImageIdIndex,
        isSourceBinding,
        maxImageIdIndex: resolvedView.state.maxImageIdIndex,
        presentation: getPlanarResolvedViewPresentation(resolvedView),
        resolvedICamera,
        resolvedView,
    };
}
function getPlanarResolvedViewPresentation(resolvedView) {
    return {
        pan: resolvedView.pan,
        zoom: resolvedView.zoom,
        scale: resolvedView.scale,
        rotation: resolvedView.rotation,
        flipHorizontal: resolvedView.state.viewState.flipHorizontal ?? false,
        flipVertical: resolvedView.state.viewState.flipVertical ?? false,
    };
}