@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

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

@@ -0,0 +1,406 @@
+import { vec3 } from 'gl-matrix';
+import { ActorRenderMode } from '../../../types';
+import getClosestImageId from '../../../utilities/getClosestImageId';
+import imageIdToURI from '../../../utilities/imageIdToURI';
+import isEqual from '../../../utilities/isEqual';
+import { getDimensionGroupReferenceContext, } from '../genericViewportReferenceCompatibility';
+import { getPlanarReferencedImageId, getPlanarViewReference, getPlanarViewReferenceId, isPlanarPlaneViewable, } from './planarViewReference';
+import { resolvePlanarViewportView } from './PlanarResolvedView';
+class PlanarViewReferenceController {
+    constructor(host) {
+        this.host = host;
+    }
+    getVolumeId(viewRefSpecifier = {}) {
+        return (this.getPlanarReferenceContext(viewRefSpecifier)?.data.volumeId ??
+            this.getCurrentPlanarReferenceContext()?.data.volumeId);
+    }
+    getCurrentImageId(viewRefSpecifier = {}) {
+        const referenceContext = this.getPlanarReferenceContext(viewRefSpecifier);
+        return getPlanarReferencedImageId({
+            viewState: this.host.getViewState(),
+            data: referenceContext?.data,
+            frameOfReferenceUID: referenceContext?.frameOfReferenceUID,
+            rendering: referenceContext?.rendering,
+            renderContext: this.host.getRenderContext(),
+            viewRefSpecifier,
+        });
+    }
+    getViewReference(viewRefSpecifier = {}) {
+        const referenceContext = this.getPlanarReferenceContext(viewRefSpecifier);
+        return getPlanarViewReference({
+            viewState: this.host.getViewState(),
+            dataId: referenceContext?.dataId,
+            frameOfReferenceUID: referenceContext?.frameOfReferenceUID ?? this.getFrameOfReferenceUID(),
+            data: referenceContext?.data,
+            rendering: referenceContext?.rendering,
+            renderContext: this.host.getRenderContext(),
+            viewRefSpecifier,
+        });
+    }
+    getViewReferenceId(viewRefSpecifier = {}) {
+        const referenceContext = this.getPlanarReferenceContext(viewRefSpecifier);
+        return getPlanarViewReferenceId({
+            viewState: this.host.getViewState(),
+            frameOfReferenceUID: referenceContext?.frameOfReferenceUID,
+            data: referenceContext?.data,
+            rendering: referenceContext?.rendering,
+            renderContext: this.host.getRenderContext(),
+            viewRefSpecifier,
+        });
+    }
+    setViewReference(viewRef) {
+        if (!viewRef) {
+            return;
+        }
+        const targetContext = this.resolveViewReferenceContext(viewRef);
+        if (!targetContext) {
+            return;
+        }
+        const didActivateBinding = this.activatePlanarReferenceContext(targetContext.dataId);
+        const didApplyReference = this.applyViewReferenceToCurrentBinding(viewRef);
+        if (didActivateBinding && !didApplyReference) {
+            this.host.render();
+        }
+    }
+    getFrameOfReferenceUID() {
+        const frameOfReferenceUID = this.resolveFrameOfReferenceUID();
+        return (this.host
+            .getResolvedView({
+            frameOfReferenceUID,
+        })
+            ?.getFrameOfReferenceUID() ?? frameOfReferenceUID);
+    }
+    resolveFrameOfReferenceUID() {
+        const binding = this.host.getCurrentBinding();
+        return (binding?.getFrameOfReferenceUID() ??
+            `${this.host.viewportType}-viewport-${this.host.viewportId}`);
+    }
+    isPlaneViewable(planeRestriction, options) {
+        return isPlanarPlaneViewable({
+            viewState: this.host.getViewState(),
+            frameOfReferenceUID: this.getFrameOfReferenceUID(),
+            options,
+            planeRestriction,
+            rendering: this.getCurrentPlanarRendering(),
+            renderContext: this.host.getRenderContext(),
+        });
+    }
+    getReferenceViewContexts(fallbackContexts) {
+        const referenceContexts = this.getAllPlanarReferenceContexts();
+        if (!referenceContexts.length) {
+            return fallbackContexts;
+        }
+        return referenceContexts.map((referenceContext) => this.getGenericViewportReferenceContext(referenceContext));
+    }
+    getPlanarReferenceContext(viewRefSpecifier = {}) {
+        if (viewRefSpecifier.volumeId) {
+            return (this.findPlanarReferenceContextByVolumeId(viewRefSpecifier.volumeId) ??
+                this.getCurrentPlanarReferenceContext());
+        }
+        return this.getCurrentPlanarReferenceContext();
+    }
+    getCurrentPlanarReferenceContext() {
+        const activeDataId = this.host.getActiveDataId();
+        if (activeDataId) {
+            const activeContext = this.getPlanarReferenceContextByDataId(activeDataId);
+            if (activeContext) {
+                return activeContext;
+            }
+        }
+        for (const [dataId] of this.host.getBindings()) {
+            return this.getPlanarReferenceContextByDataId(dataId);
+        }
+    }
+    getPlanarReferenceContextByDataId(dataId) {
+        const binding = this.host.getBinding(dataId);
+        if (!binding) {
+            return;
+        }
+        return {
+            dataId,
+            data: binding.data,
+            frameOfReferenceUID: binding.getFrameOfReferenceUID() ??
+                `${this.host.viewportType}-viewport-${this.host.viewportId}`,
+            rendering: binding.rendering,
+        };
+    }
+    getAllPlanarReferenceContexts() {
+        const contexts = [];
+        for (const [dataId] of this.host.getBindings()) {
+            const referenceContext = this.getPlanarReferenceContextByDataId(dataId);
+            if (referenceContext) {
+                contexts.push(referenceContext);
+            }
+        }
+        return contexts;
+    }
+    getGenericViewportReferenceContext(referenceContext) {
+        const resolvedView = resolvePlanarViewportView({
+            viewState: this.host.getViewState(),
+            data: referenceContext.data,
+            frameOfReferenceUID: referenceContext.frameOfReferenceUID,
+            rendering: referenceContext.rendering,
+            renderContext: this.host.getRenderContext(),
+        })?.toICamera();
+        const volumeId = referenceContext.data.volumeId;
+        return {
+            dataId: referenceContext.dataId,
+            dataIds: [referenceContext.data.id],
+            frameOfReferenceUID: referenceContext.frameOfReferenceUID,
+            imageIds: this.getImageIdsForReferenceContext(referenceContext),
+            currentImageIdIndex: referenceContext.rendering.currentImageIdIndex,
+            volumeId,
+            volumeIds: volumeId ? [volumeId] : undefined,
+            cameraFocalPoint: resolvedView?.focalPoint,
+            viewPlaneNormal: resolvedView?.viewPlaneNormal,
+            ...getDimensionGroupReferenceContext(referenceContext.data.imageVolume),
+        };
+    }
+    findPlanarReferenceContextByVolumeId(volumeId) {
+        for (const [dataId, binding] of this.host.getBindings()) {
+            const bindingData = binding.data;
+            if (bindingData.volumeId === volumeId) {
+                return this.getPlanarReferenceContextByDataId(dataId);
+            }
+        }
+    }
+    findPlanarReferenceContextByImageReference(referencedImageId, referencedImageURI) {
+        const targetImageURI = referencedImageURI ||
+            (referencedImageId ? imageIdToURI(referencedImageId) : undefined);
+        if (!targetImageURI) {
+            return;
+        }
+        for (const referenceContext of this.getAllPlanarReferenceContexts()) {
+            if (this.getImageIdsForReferenceContext(referenceContext).some((imageId) => imageIdToURI(imageId) === targetImageURI)) {
+                return referenceContext;
+            }
+        }
+    }
+    resolveViewReferenceContext(viewRef) {
+        if (viewRef.dataId) {
+            const dataContext = this.getPlanarReferenceContextByDataId(viewRef.dataId);
+            if (dataContext) {
+                return dataContext;
+            }
+        }
+        if (viewRef.volumeId) {
+            const volumeContext = this.findPlanarReferenceContextByVolumeId(viewRef.volumeId);
+            if (volumeContext) {
+                return volumeContext;
+            }
+        }
+        const imageContext = this.findPlanarReferenceContextByImageReference(viewRef.referencedImageId, viewRef.referencedImageURI);
+        if (imageContext) {
+            return imageContext;
+        }
+        const currentReferenceContext = this.getCurrentPlanarReferenceContext();
+        if (viewRef.FrameOfReferenceUID &&
+            currentReferenceContext?.frameOfReferenceUID !==
+                viewRef.FrameOfReferenceUID) {
+            return;
+        }
+        return currentReferenceContext;
+    }
+    activatePlanarReferenceContext(dataId) {
+        if (this.host.getActiveDataId() === dataId) {
+            return false;
+        }
+        this.host.promoteSourceDataId(dataId);
+        this.host.updateBindingsCameraState();
+        return true;
+    }
+    applyViewReferenceToCurrentBinding(viewRef) {
+        const referenceContext = this.getCurrentPlanarReferenceContext();
+        if (!referenceContext ||
+            (viewRef.FrameOfReferenceUID &&
+                referenceContext.frameOfReferenceUID !== viewRef.FrameOfReferenceUID)) {
+            return false;
+        }
+        const { rendering } = referenceContext;
+        if (rendering.renderMode === ActorRenderMode.CPU_IMAGE ||
+            rendering.renderMode === ActorRenderMode.VTK_IMAGE) {
+            return this.applyImageViewReference(referenceContext, viewRef);
+        }
+        return this.applyVolumeViewReference(referenceContext, viewRef);
+    }
+    applyImageViewReference(referenceContext, viewRef) {
+        const imageIds = this.getImageIdsForReferenceContext(referenceContext);
+        const referencedImageIndex = this.findImageIdIndexByReference(imageIds, viewRef.referencedImageId, viewRef.referencedImageURI);
+        if (typeof referencedImageIndex === 'number') {
+            this.host.setImageIdIndex(referencedImageIndex);
+            return true;
+        }
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.host.setImageIdIndex(viewRef.sliceIndex);
+            return true;
+        }
+        return false;
+    }
+    applyVolumeViewReference(referenceContext, viewRef) {
+        const normalizedViewRef = this.normalizeVolumeViewReference(referenceContext, viewRef);
+        const resolvedView = this.host
+            .getResolvedView({
+            frameOfReferenceUID: referenceContext.frameOfReferenceUID,
+        })
+            ?.toICamera();
+        if (!resolvedView?.viewPlaneNormal) {
+            return false;
+        }
+        const currentViewPlaneNormal = resolvedView.viewPlaneNormal;
+        const refViewPlaneNormal = normalizedViewRef.viewPlaneNormal;
+        const shouldReorient = refViewPlaneNormal &&
+            !this.areNormalsEqual(currentViewPlaneNormal, refViewPlaneNormal) &&
+            !this.areNormalsOpposite(currentViewPlaneNormal, refViewPlaneNormal);
+        const effectiveViewPlaneNormal = refViewPlaneNormal ?? currentViewPlaneNormal;
+        const isOppositeNormal = !shouldReorient &&
+            this.areNormalsOpposite(currentViewPlaneNormal, effectiveViewPlaneNormal);
+        const nextImageIdIndex = this.resolveVolumeReferenceImageIdIndex(referenceContext, normalizedViewRef, effectiveViewPlaneNormal, isOppositeNormal);
+        const viewStatePatch = {};
+        if (shouldReorient && refViewPlaneNormal) {
+            viewStatePatch.orientation = {
+                viewPlaneNormal: [...refViewPlaneNormal],
+                ...(normalizedViewRef.viewUp
+                    ? {
+                        viewUp: [...normalizedViewRef.viewUp],
+                    }
+                    : {}),
+            };
+        }
+        const sliceWorldPoint = normalizedViewRef.cameraFocalPoint ??
+            (typeof nextImageIdIndex === 'number'
+                ? this.host.getVolumeSliceWorldPointForImageIdIndex(nextImageIdIndex)
+                : undefined);
+        if (sliceWorldPoint) {
+            viewStatePatch.slice = {
+                kind: 'volumePoint',
+                sliceWorldPoint: [...sliceWorldPoint],
+            };
+        }
+        if (!Object.keys(viewStatePatch).length) {
+            return false;
+        }
+        this.host.setViewState(viewStatePatch);
+        return true;
+    }
+    normalizeVolumeViewReference(referenceContext, viewRef) {
+        if (!viewRef.planeRestriction || viewRef.viewPlaneNormal) {
+            return viewRef;
+        }
+        const orientation = this.deriveOrientationFromPlaneRestriction(referenceContext, viewRef.planeRestriction);
+        return {
+            ...viewRef,
+            cameraFocalPoint: viewRef.cameraFocalPoint ?? viewRef.planeRestriction.point,
+            ...orientation,
+        };
+    }
+    deriveOrientationFromPlaneRestriction(referenceContext, planeRestriction) {
+        const resolvedView = this.host
+            .getResolvedView({
+            frameOfReferenceUID: referenceContext.frameOfReferenceUID,
+        })
+            ?.toICamera();
+        const currentViewPlaneNormal = resolvedView?.viewPlaneNormal;
+        const currentViewUp = resolvedView?.viewUp;
+        const { inPlaneVector1, inPlaneVector2 } = planeRestriction;
+        const result = {};
+        if (currentViewPlaneNormal &&
+            this.isPlaneRestrictionCompatibleWithNormal(planeRestriction, currentViewPlaneNormal)) {
+            result.viewPlaneNormal = [...currentViewPlaneNormal];
+            if (inPlaneVector1) {
+                result.viewUp = [...inPlaneVector1];
+            }
+            else if (currentViewUp) {
+                result.viewUp = [...currentViewUp];
+            }
+            return result;
+        }
+        let derivedViewPlaneNormal;
+        if (inPlaneVector1 && inPlaneVector2) {
+            const cross = vec3.cross(vec3.create(), inPlaneVector2, inPlaneVector1);
+            if (vec3.length(cross) > 0) {
+                vec3.normalize(cross, cross);
+                derivedViewPlaneNormal = [...cross];
+            }
+        }
+        else if (inPlaneVector1 && currentViewPlaneNormal) {
+            const cross = vec3.cross(vec3.create(), currentViewPlaneNormal, inPlaneVector1);
+            if (vec3.length(cross) > 0) {
+                vec3.normalize(cross, cross);
+                derivedViewPlaneNormal = [...cross];
+            }
+        }
+        if (derivedViewPlaneNormal) {
+            result.viewPlaneNormal = derivedViewPlaneNormal;
+        }
+        if (inPlaneVector1) {
+            result.viewUp = [...inPlaneVector1];
+        }
+        else if (currentViewUp) {
+            result.viewUp = [...currentViewUp];
+        }
+        return result;
+    }
+    isPlaneRestrictionCompatibleWithNormal(planeRestriction, viewPlaneNormal) {
+        return ((!planeRestriction.inPlaneVector1 ||
+            isEqual(0, vec3.dot(viewPlaneNormal, planeRestriction.inPlaneVector1))) &&
+            (!planeRestriction.inPlaneVector2 ||
+                isEqual(0, vec3.dot(viewPlaneNormal, planeRestriction.inPlaneVector2))));
+    }
+    resolveVolumeReferenceImageIdIndex(referenceContext, viewRef, effectiveViewPlaneNormal, isOppositeNormal) {
+        const { rendering } = referenceContext;
+        if (rendering.renderMode !== ActorRenderMode.CPU_VOLUME &&
+            rendering.renderMode !== ActorRenderMode.VTK_VOLUME_SLICE) {
+            return;
+        }
+        const imageIds = this.getImageIdsForReferenceContext(referenceContext);
+        const maxImageIdIndex = rendering.maxImageIdIndex;
+        if (typeof viewRef.sliceIndex === 'number' &&
+            viewRef.volumeId === referenceContext.data.volumeId &&
+            viewRef.viewPlaneNormal) {
+            const targetSliceIndex = isOppositeNormal
+                ? maxImageIdIndex - viewRef.sliceIndex
+                : viewRef.sliceIndex;
+            return Math.min(Math.max(0, targetSliceIndex), maxImageIdIndex);
+        }
+        const referencedImageIndex = this.findImageIdIndexByReference(imageIds, viewRef.referencedImageId, viewRef.referencedImageURI);
+        if (typeof referencedImageIndex === 'number') {
+            return referencedImageIndex;
+        }
+        const targetPoint = viewRef.cameraFocalPoint ?? viewRef.planeRestriction?.point;
+        if (targetPoint) {
+            const referencedImageId = getClosestImageId(rendering.imageVolume, targetPoint, effectiveViewPlaneNormal);
+            return this.findImageIdIndexByReference(imageIds, referencedImageId);
+        }
+        if (typeof viewRef.sliceIndex === 'number') {
+            return Math.min(Math.max(0, viewRef.sliceIndex), maxImageIdIndex);
+        }
+    }
+    getImageIdsForReferenceContext(referenceContext) {
+        return (referenceContext.data.imageVolume?.imageIds ||
+            referenceContext.data.imageIds);
+    }
+    findImageIdIndexByReference(imageIds, referencedImageId, referencedImageURI) {
+        const targetImageURI = referencedImageURI ||
+            (referencedImageId ? imageIdToURI(referencedImageId) : undefined);
+        if (!targetImageURI) {
+            return;
+        }
+        const foundImageIdIndex = imageIds.findIndex((imageId) => imageIdToURI(imageId) === targetImageURI);
+        return foundImageIdIndex >= 0 ? foundImageIdIndex : undefined;
+    }
+    getCurrentPlanarRendering() {
+        return this.host.getCurrentBinding()?.rendering;
+    }
+    areNormalsEqual(currentViewPlaneNormal, targetViewPlaneNormal) {
+        return Boolean(currentViewPlaneNormal &&
+            targetViewPlaneNormal &&
+            isEqual(currentViewPlaneNormal, targetViewPlaneNormal));
+    }
+    areNormalsOpposite(currentViewPlaneNormal, targetViewPlaneNormal) {
+        if (!currentViewPlaneNormal || !targetViewPlaneNormal) {
+            return false;
+        }
+        return isEqual(vec3.negate(vec3.create(), currentViewPlaneNormal), targetViewPlaneNormal);
+    }
+}
+export default PlanarViewReferenceController;

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

@@ -0,0 +1,187 @@
+import { OrientationAxis, ViewportType, VOILUTFunctionType } from '../../../enums';
+import type { ActorEntry, ICamera, IImage, IStackInput, OrientationVectors, Point2, Point3, ReferenceCompatibleOptions, VOIRange, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type { PlaneRestriction } from '../../../types/IViewport';
+import type ViewportInputOptions from '../../../types/ViewportInputOptions';
+import GenericViewport from '../GenericViewport';
+import type { GenericViewportReferenceContext } from '../genericViewportReferenceCompatibility';
+import { type PlanarScaleInput } from './planarCameraScale';
+import { resolvePlanarViewportView } from './PlanarResolvedView';
+import type { PlanarRendering } from './planarRuntimeTypes';
+export type { PlanarReferenceContext } from './PlanarViewReferenceController';
+import type { PlanarViewState, PlanarDataPresentation, PlanarDisplayArea, PlanarSetDataOptions, PlanarViewportRenderContext, PlanarViewportInput, PlanarViewportInputOptions } from './PlanarViewportTypes';
+type PlanarSetOrientationInput = OrientationAxis.ACQUISITION | OrientationAxis.AXIAL | OrientationAxis.CORONAL | OrientationAxis.SAGITTAL | OrientationAxis.REFORMAT | OrientationAxis.AXIAL_REFORMAT | OrientationAxis.CORONAL_REFORMAT | OrientationAxis.SAGITTAL_REFORMAT | OrientationVectors;
+type ResolvedPlanarViewportView = NonNullable<ReturnType<typeof resolvePlanarViewportView>>;
+type PlanarResetViewStateOptions = {
+    resetPan?: boolean;
+    resetZoom?: boolean;
+    resetOrientation?: boolean;
+    resetFlip?: boolean;
+};
+declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarDataPresentation, PlanarViewportRenderContext> {
+    readonly type = ViewportType.PLANAR_NEXT;
+    readonly renderingEngineId: string;
+    readonly canvas: HTMLCanvasElement;
+    sWidth: number;
+    sHeight: number;
+    defaultOptions: PlanarViewportInputOptions;
+    options: PlanarViewportInputOptions;
+    suppressEvents: boolean;
+    protected renderContext: PlanarViewportRenderContext;
+    private readonly mountedData;
+    private readonly viewReferences;
+    private cpuCanvas?;
+    private renderImageObjectDataId?;
+    private resolvedViewCache?;
+    private resolvedViewCacheRevision;
+    private setDataRequestId;
+    static get useCustomRenderingPipeline(): boolean;
+    constructor(args: PlanarViewportInput);
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: PlanarSetDataOptions;
+    }>): Promise<void>;
+    addDisplaySet(displaySetId: string, options?: PlanarSetDataOptions): Promise<void>;
+    private addDisplaySetInternal;
+    removeData(dataId: string): void;
+    getActors(): ActorEntry[];
+    getDefaultActor(): ActorEntry | undefined;
+    renderImageObject(image: IImage): Promise<void>;
+    getCanvas(): HTMLCanvasElement;
+    addImages(stackInputs: IStackInput[]): Promise<void>;
+    getImageDataMetadata(image: IImage): {
+        imagePlaneModule: import("../../../types").ImagePlaneModule;
+        imagePixelModule: import("../../../types").ImagePixelModule;
+        bitsAllocated: number;
+        numVoxels: number;
+        numberOfComponents: number;
+        origin: Point3;
+        direction: import("../../../types").Mat3;
+        dimensions: Point3;
+        spacing: Point3;
+        voiLUTFunction: VOILUTFunctionType;
+        modality: string;
+        scalingFactor: number;
+        calibration: import("packages/metadata/dist/esm").IImageCalibration;
+        scanAxisNormal: Point3;
+    };
+    getImageIds(): string[];
+    getVolumeId(viewRefSpecifier?: ViewReferenceSpecifier): string | undefined;
+    getSourceDataId(): string | undefined;
+    getDefaultVOIRange(dataId?: string): VOIRange | undefined;
+    getCurrentImageIdIndex(): number;
+    getCurrentImageId(viewRefSpecifier?: ViewReferenceSpecifier): string | undefined;
+    getSliceIndex(): number;
+    protected normalizeViewState(viewState: PlanarViewState): PlanarViewState;
+    setViewState(viewStatePatch: Partial<PlanarViewState>): void;
+    setDisplaySetPresentation(props: Partial<PlanarDataPresentation>): void;
+    setDisplaySetPresentation(displaySetId: string, props: Partial<PlanarDataPresentation>): void;
+    protected setDataPresentationState(dataId: string, props: PlanarDataPresentation): void;
+    getRotation(): number;
+    getAnchorWorld(): Point3 | undefined;
+    setAnchorWorld(point?: Point3): void;
+    setOptions(options: ViewportInputOptions, immediate?: boolean): void;
+    reset(immediate?: boolean): void;
+    getDisplayArea(): PlanarDisplayArea | undefined;
+    setDisplayArea(displayArea: PlanarDisplayArea, suppressEvents?: boolean): void;
+    getZoom(): number;
+    getScale(): Point2;
+    setZoom(zoom: number, canvasPoint?: Point2): void;
+    setScale(scale: PlanarScaleInput, canvasPoint?: Point2): void;
+    getPan(): Point2;
+    setPan(nextPan: Point2): void;
+    setScaleAtCanvasPoint(scale: PlanarScaleInput, canvasPoint: Point2): void;
+    getViewState(): PlanarViewState;
+    getResolvedView(args?: {
+        frameOfReferenceUID?: string;
+        sliceIndex?: number;
+    }): ResolvedPlanarViewportView;
+    getRenderingEngine(): import("../..").RenderingEngine;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    getViewReferenceId(viewRefSpecifier?: ViewReferenceSpecifier): string;
+    setViewReference(viewRef: ViewReference): void;
+    getImageData(): unknown;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string;
+    hasImageId(imageId: string): boolean;
+    hasImageURI(imageURI: string): boolean;
+    hasVolumeId(volumeId: string): boolean;
+    hasVolumeURI(volumeURI: string): boolean;
+    isPlaneViewable(planeRestriction: PlaneRestriction, options?: ReferenceCompatibleOptions): boolean;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    setImageIdIndex(imageIdIndex: number): Promise<string>;
+    scroll(delta: number): Promise<string>;
+    setOrientation(orientation: PlanarSetOrientationInput): void;
+    resetViewState(options?: PlanarResetViewStateOptions): boolean;
+    resetViewStateForResize(): boolean;
+    getUseCustomRenderingPipeline(): boolean;
+    setRendered(): void;
+    resize(): void;
+    render(): void;
+    protected onDestroy(): void;
+    protected modified(previousCamera?: ICamera): void;
+    protected renderBindings(): boolean;
+    private requestRenderingEngineRender;
+    private setRenderModeVisibility;
+    protected createLegacyCompatibilityHost(): {
+        getElement: () => HTMLDivElement;
+        getViewportId: () => string;
+        getRequestedOrientation: () => import("./PlanarViewportTypes").PlanarOrientation;
+        prepareVolumeCompatibilityCamera: () => void;
+        setDisplaySets: (...entries: any[]) => Promise<void>;
+        setImageIdIndex: (imageIdIndex: any) => Promise<string>;
+        getCurrentImageId: () => string;
+        render: () => void;
+        removeBindingsExcept: (keepDataIds: any) => void;
+        setCameraOrientation: (orientation: any) => void;
+        setDataPresentationState: (dataId: any, presentation: any) => void;
+        setDisplaySetPresentation: (displaySetId: any, presentation: any) => void;
+        getDisplaySetPresentation: (dataId: any) => PlanarDataPresentation;
+        getCameraOrientation: () => import("./PlanarViewportTypes").PlanarOrientation;
+        getCurrentPlanarRendering: () => PlanarRendering;
+        getActiveDataId: () => string;
+        getFirstBoundDataId: () => string;
+        findDataIdByVolumeId: (volumeId: any) => string;
+        getBindingActor: (dataId: any) => unknown;
+        getDefaultVOIRange: (dataId: any) => VOIRange;
+        getImageCount: () => number;
+        getMaxImageIdIndex: () => number;
+    };
+    protected updateBindingsCameraState(): void;
+    private resizeBindingsWithActiveFirst;
+    private getActiveImageIdIndex;
+    protected getMaxImageIdIndex(): number;
+    private getVolumeSliceWorldPointForImageIdIndex;
+    private getPlanarData;
+    protected getCurrentBinding(): import("./PlanarMountedData").PlanarDataBinding;
+    private getDataSet;
+    private loadPlanarData;
+    private applyLoadedPlanarViewState;
+    private createInitialVolumeSliceState;
+    private resolveRequestedOrientation;
+    private resolveSetOrientation;
+    protected removeBindingsExcept(keepDataIds: Set<string>): void;
+    private resolveStackInputImage;
+    private resolveOverlayReference;
+    private resolveOverlayDataId;
+    protected findBindingDataIdByActorEntryUID(actorEntryUID: string): string | undefined;
+    protected findDataIdByVolumeId(volumeId: string): string | undefined;
+    protected getCurrentPlanarRendering(): PlanarRendering | undefined;
+    private resolveViewState;
+    private getProjectionSnapshot;
+    private resolveCachedViewState;
+    private clearResolvedViewCache;
+    private resolveFrameOfReferenceUID;
+    private getFallbackPan;
+    private getFallbackViewStateWithPan;
+    private buildFallbackCanvasToWorld;
+    private buildFallbackWorldToCanvas;
+    private applyResolvedViewState;
+    private getResolvedCameraForEvent;
+    protected getCameraForEvent(): ICamera;
+    private getCurrentPresentation;
+    private getCurrentCanvasDimensions;
+    private getCurrentPlanarData;
+    protected getReferenceViewContexts(): GenericViewportReferenceContext[];
+}
+export default PlanarViewport;