@cornerstonejs/core/dist/esm/RenderingEngine/VideoViewport.d.ts

Cornerstone3D Core

import type { mat4 } from 'gl-matrix';
import { VideoEnums as VideoViewportEnum } from '../enums/index.js';
import type { DisplaySetId } from './GenericViewport/ViewportArchitectureTypes.js';
import type { VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types/index.js';
import { Transform } from './helpers/cpuFallback/rendering/transform.js';
import Viewport from './Viewport.js';
import CanvasActor from './CanvasActor/index.js';
export type CanvasScalarData = Uint8ClampedArray & {
    frameNumber?: number;
    getRange?: () => [number, number];
};
declare class VideoViewport extends Viewport {
    static frameRangeExtractor: RegExp;
    modality: any;
    protected imageId: string;
    readonly uid: any;
    readonly renderingEngineId: string;
    readonly canvasContext: CanvasRenderingContext2D;
    private videoElement?;
    private videoWidth;
    private videoHeight;
    private loop;
    private mute;
    private isPlaying;
    private scrollSpeed;
    private playbackRate;
    private scalarData;
    private initialRender;
    private frameRange;
    protected metadata: any;
    private fps;
    private numberOfFrames;
    private videoCamera;
    private feFilter;
    private averageWhite;
    private voiRange;
    constructor(props: VideoViewportInput);
    static get useCustomRenderingPipeline(): boolean;
    private addEventListeners;
    private removeEventListeners;
    private elementDisabledHandler;
    getImageDataMetadata(image: IImage | string): import("../utilities/VideoUtilities.js").VideoImageMetadata;
    setDataIds(imageIds: string[], options?: ImageSetOptions): void;
    setDataList(entries: Array<{
        dataId: string;
        options?: Record<string, unknown>;
    }>): Promise<unknown>;
    setDisplaySets(...entries: Array<{
        displaySetId: DisplaySetId;
        options?: {
            frameNumber?: number;
            viewReference?: {
                sliceIndex?: number;
            };
        };
    }>): Promise<void>;
    setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
    private setVideoURL;
    getImageIds(): string[];
    togglePlayPause(): boolean;
    play(): Promise<void>;
    pause(): void;
    scroll(delta?: number): Promise<void>;
    start(): Promise<void>;
    end(): Promise<void>;
    setTime(timeInSeconds: number): Promise<void>;
    getSliceViewInfo(): {
        width: number;
        height: number;
        sliceIndex: number;
        slicePlane: number;
        sliceToIndexMatrix: mat4;
        indexToSliceMatrix: mat4;
    };
    setFrameNumber(frame: number): Promise<void>;
    setFrameRange(frameRange: number[]): void;
    getSliceIndexForImage(reference: string | ViewReference): number;
    getFrameRange(): [number, number];
    setProperties(props: VideoViewportProperties): void;
    setPlaybackRate(rate?: number): void;
    setScrollSpeed(scrollSpeed?: number, unit?: VideoViewportEnum.SpeedUnit): void;
    getProperties: () => VideoViewportProperties;
    resetProperties(): void;
    protected getScalarData(): CanvasScalarData;
    getImageData(): IImageData | CPUIImageData;
    getMiddleSliceData: () => never;
    useCustomRenderingPipeline: boolean;
    hasImageURI(imageURI: string): boolean;
    setVOI(voiRange: VOIRange): void;
    setWindowLevel(windowWidth?: number, windowCenter?: number): void;
    setAverageWhite(averageWhite: [number, number, number]): void;
    setCamera(camera: ICamera): void;
    getCurrentImageId(index?: number): string;
    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
    setViewReference(viewRef: ViewReference): void;
    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
    getFrameNumber(): number;
    getCurrentImageIdIndex(): number;
    getSliceIndex(): number;
    getCamera(): ICamera;
    resetCamera: () => boolean;
    getNumberOfSlices: () => number;
    getFrameRate(): number;
    getFrameOfReferenceUID: () => string;
    resize: () => void;
    canvasToWorld: (canvasPos: Point2, destPos?: Point3) => Point3;
    worldToCanvas: (worldPos: Point3) => Point2;
    getPan(): Point2;
    getRotation: () => number;
    protected canvasToIndex: (canvasPos: Point2) => Point2;
    protected indexToCanvas: (indexPos: Point2) => Point2;
    private refreshRenderValues;
    private getWorldToCanvasRatio;
    private getCanvasToWorldRatio;
    customRenderViewportToCanvas: () => void;
    protected getTransform(): Transform;
    updateCameraClippingPlanesAndRange(): void;
    addImages(stackInputs: IStackInput[]): void;
    protected createActorMapper(image: any): CanvasActor;
    private renderFrame;
    private renderWhilstPlaying;
}
export default VideoViewport;