@cornerstonejs/core 4.22.13 → 5.0.0

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

@@ -0,0 +1,59 @@
+import { OrientationAxis } from '../../../enums';
+import { deepClone } from '../../../utilities/deepClone';
+import { clonePlanarOrientation } from './planarLegacyCompatibility';
+import { normalizePlanarRotation } from './planarViewPresentation';
+import { clonePlanarScale, normalizePlanarScaleMode, } from './planarCameraScale';
+export function cloneDisplayArea(displayArea) {
+    return deepClone(displayArea);
+}
+export function createDefaultPlanarViewState() {
+    return {
+        slice: {
+            kind: 'stackIndex',
+            imageIdIndex: 0,
+        },
+        orientation: OrientationAxis.ACQUISITION,
+        flipHorizontal: false,
+        flipVertical: false,
+        anchorCanvas: [0.5, 0.5],
+        scale: [1, 1],
+        scaleMode: 'fit',
+        rotation: 0,
+    };
+}
+function cloneSlice(slice) {
+    if (!slice) {
+        return;
+    }
+    if (slice.kind === 'stackIndex') {
+        return {
+            kind: 'stackIndex',
+            imageIdIndex: Math.max(0, Math.round(slice.imageIdIndex)),
+        };
+    }
+    return {
+        kind: 'volumePoint',
+        sliceWorldPoint: [...slice.sliceWorldPoint],
+    };
+}
+export function normalizePlanarViewState(viewState) {
+    return {
+        ...(viewState.slice ? { slice: cloneSlice(viewState.slice) } : {}),
+        orientation: clonePlanarOrientation(viewState.orientation) ??
+            OrientationAxis.ACQUISITION,
+        flipHorizontal: viewState.flipHorizontal === true,
+        flipVertical: viewState.flipVertical === true,
+        anchorCanvas: viewState.anchorCanvas
+            ? [...viewState.anchorCanvas]
+            : [0.5, 0.5],
+        scale: clonePlanarScale(viewState.scale),
+        scaleMode: normalizePlanarScaleMode(viewState.displayArea?.scaleMode ?? viewState.scaleMode),
+        rotation: normalizePlanarRotation(viewState.rotation ?? 0),
+        ...(viewState.displayArea
+            ? { displayArea: cloneDisplayArea(viewState.displayArea) }
+            : {}),
+        ...(viewState.anchorWorld
+            ? { anchorWorld: [...viewState.anchorWorld] }
+            : {}),
+    };
+}

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

@@ -0,0 +1,10 @@
+import type vtkImageResliceMapper from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper';
+import type vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import type { VOIRange } from '../../../types';
+import type { PlanarDataPresentation } from './PlanarViewportTypes';
+export declare function applyPlanarVolumePresentation(args: {
+    actor: vtkImageSlice;
+    mapper: vtkImageResliceMapper;
+    defaultVOIRange?: VOIRange;
+    props?: PlanarDataPresentation;
+}): void;

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

@@ -0,0 +1,223 @@
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import { createPlanarRGBTransferFunction } from '../../helpers/planarImageRendering';
+import { mapBlendModeToSlabType, resolveSlabThickness, } from './planarVolumeSliceBlendMode';
+export function applyPlanarVolumePresentation(args) {
+    const { actor, defaultVOIRange, mapper, props } = args;
+    const property = actor.getProperty();
+    const voiRange = props?.voiRange ?? defaultVOIRange;
+    actor.setVisibility(props?.visible === false ? false : true);
+    if (props?.interpolationType !== undefined) {
+        property.setInterpolationType(props.interpolationType);
+    }
+    if (props?.blendMode !== undefined) {
+        const slabType = mapBlendModeToSlabType(props.blendMode);
+        if (slabType !== undefined) {
+            mapper.setSlabType(slabType);
+        }
+    }
+    mapper.setSlabThickness(resolveSlabThickness(props?.slabThickness));
+    if (props?.opacity !== undefined) {
+        applyVolumeOpacity({
+            actor,
+            opacity: props.opacity,
+            voiRange,
+        });
+    }
+    if (!voiRange) {
+        return;
+    }
+    const transferFunction = createPlanarRGBTransferFunction({
+        colormap: props?.colormap,
+        invert: props?.invert,
+        voiRange,
+    });
+    property.setUseLookupTableScalarRange(true);
+    property.setRGBTransferFunction(0, transferFunction);
+    applyColormapOpacity({
+        actor,
+        colormap: props?.colormap,
+        voiRange,
+    });
+}
+function applyVolumeOpacity(args) {
+    const { actor, opacity, voiRange } = args;
+    if (getVolumeNumberOfComponents(actor) < 2) {
+        actor.getProperty().setOpacity(opacity);
+        return;
+    }
+    const opacityFunction = vtkPiecewiseFunction.newInstance();
+    const range = resolveVolumeOpacityRange(actor, voiRange);
+    opacityFunction.addPoint(range.lower, opacity);
+    if (range.upper > range.lower) {
+        opacityFunction.addPoint(range.upper, opacity);
+    }
+    actor.getProperty().setScalarOpacity(0, opacityFunction);
+}
+function applyColormapOpacity(args) {
+    const { actor, colormap, voiRange } = args;
+    if (!colormap) {
+        return;
+    }
+    if (colormap.opacity === undefined && colormap.threshold === undefined) {
+        return;
+    }
+    const range = resolveVolumeOpacityRange(actor, voiRange);
+    const opacityFunction = vtkPiecewiseFunction.newInstance();
+    const points = buildColormapOpacityPoints({
+        colormap,
+        range,
+        fallbackOpacity: getCurrentMaxOpacity(actor),
+    });
+    points.forEach(([value, opacity]) => {
+        opacityFunction.addPoint(value, opacity);
+    });
+    actor.getProperty().setScalarOpacity(0, opacityFunction);
+}
+function buildColormapOpacityPoints(args) {
+    const { colormap, range, fallbackOpacity } = args;
+    const delta = Math.max(Math.abs(range.upper - range.lower) * 0.001, 1e-3);
+    const threshold = colormap.threshold !== undefined
+        ? Math.max(range.lower, Math.min(range.upper, colormap.threshold))
+        : undefined;
+    if (Array.isArray(colormap.opacity) && colormap.opacity.length) {
+        const sortedPoints = colormap.opacity
+            .map(({ opacity, value }) => ({
+            opacity: clampToUnit(opacity),
+            value,
+        }))
+            .sort((a, b) => a.value - b.value);
+        if (threshold === undefined) {
+            return dedupeOpacityPoints(sortedPoints.map(({ value, opacity }) => [value, opacity]));
+        }
+        const thresholdOpacity = resolvePointOpacityAtValue(threshold, sortedPoints, fallbackOpacity);
+        const points = [
+            [range.lower, 0],
+            [Math.max(range.lower, threshold - delta), 0],
+            [threshold, thresholdOpacity],
+        ];
+        sortedPoints.forEach(({ value, opacity }) => {
+            if (value > threshold) {
+                points.push([value, opacity]);
+            }
+        });
+        if (threshold < range.upper) {
+            const lastOpacity = points[points.length - 1][1];
+            if (points[points.length - 1][0] < range.upper) {
+                points.push([range.upper, lastOpacity]);
+            }
+        }
+        return dedupeOpacityPoints(points);
+    }
+    const opacity = colormap.opacity !== undefined
+        ? clampToUnit(colormap.opacity)
+        : clampToUnit(fallbackOpacity);
+    if (threshold === undefined) {
+        return [
+            [range.lower, opacity],
+            [range.upper, opacity],
+        ];
+    }
+    if (threshold >= range.upper) {
+        return [
+            [range.lower, 0],
+            [range.upper, 0],
+        ];
+    }
+    return [
+        [range.lower, 0],
+        [Math.max(range.lower, threshold - delta), 0],
+        [threshold, opacity],
+        [range.upper, opacity],
+    ];
+}
+function resolvePointOpacityAtValue(scalarValue, opacityPoints, fallbackOpacity) {
+    if (!opacityPoints.length) {
+        return clampToUnit(fallbackOpacity);
+    }
+    if (scalarValue <= opacityPoints[0].value) {
+        return opacityPoints[0].opacity;
+    }
+    for (let i = 1; i < opacityPoints.length; i++) {
+        const previous = opacityPoints[i - 1];
+        const current = opacityPoints[i];
+        if (scalarValue <= current.value) {
+            const pointRange = current.value - previous.value;
+            const t = pointRange > 0 ? (scalarValue - previous.value) / pointRange : 0;
+            return clampToUnit(previous.opacity + (current.opacity - previous.opacity) * t);
+        }
+    }
+    return opacityPoints[opacityPoints.length - 1].opacity;
+}
+function dedupeOpacityPoints(points) {
+    const deduped = [];
+    points.forEach(([value, opacity]) => {
+        const lastPoint = deduped[deduped.length - 1];
+        if (lastPoint && lastPoint[0] === value) {
+            lastPoint[1] = opacity;
+            return;
+        }
+        deduped.push([value, opacity]);
+    });
+    return deduped;
+}
+function getCurrentMaxOpacity(actor) {
+    const opacityFunction = actor.getProperty().getScalarOpacity(0);
+    const opacityValues = opacityFunction?.getDataPointer?.();
+    if (!opacityValues?.length) {
+        return actor.getProperty().getOpacity?.() ?? 1;
+    }
+    let maxOpacity = 0;
+    for (let i = 1; i < opacityValues.length; i += 2) {
+        if (opacityValues[i] > maxOpacity) {
+            maxOpacity = opacityValues[i];
+        }
+    }
+    return clampToUnit(maxOpacity || 1);
+}
+function clampToUnit(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function getVolumeNumberOfComponents(actor) {
+    const mapperInputData = actor.getMapper()?.getInputData?.();
+    const scalars = mapperInputData?.getPointData?.()?.getScalars?.();
+    const imageDataMetadata = mapperInputData?.get?.('numberOfComponents');
+    return (scalars?.getNumberOfComponents?.() ??
+        imageDataMetadata?.numberOfComponents ??
+        1);
+}
+function resolveVolumeOpacityRange(actor, voiRange) {
+    if (voiRange &&
+        Number.isFinite(voiRange.lower) &&
+        Number.isFinite(voiRange.upper)) {
+        return voiRange;
+    }
+    const mapperInputData = actor.getMapper()?.getInputData?.();
+    const scalarRange = mapperInputData
+        ?.getPointData?.()
+        ?.getScalars?.()
+        ?.getRange?.();
+    if (scalarRange &&
+        Number.isFinite(scalarRange[0]) &&
+        Number.isFinite(scalarRange[1])) {
+        return {
+            lower: scalarRange[0],
+            upper: scalarRange[1],
+        };
+    }
+    const transferRange = actor
+        .getProperty()
+        .getRGBTransferFunction(0)
+        ?.getRange?.();
+    if (transferRange &&
+        Number.isFinite(transferRange[0]) &&
+        Number.isFinite(transferRange[1])) {
+        return {
+            lower: transferRange[0],
+            upper: transferRange[1],
+        };
+    }
+    return {
+        lower: 0,
+        upper: 1,
+    };
+}

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

@@ -0,0 +1,5 @@
+import { SlabTypes } from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper/Constants';
+import BlendModes from '../../../enums/BlendModes';
+export declare function mapBlendModeToSlabType(blendMode?: BlendModes): SlabTypes | undefined;
+export declare function mapSlabTypeToBlendMode(slabType?: SlabTypes): BlendModes;
+export declare function resolveSlabThickness(slabThickness?: number): number;

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

@@ -0,0 +1,36 @@
+import { SlabTypes } from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper/Constants';
+import { RENDERING_DEFAULTS } from '../../../constants';
+import BlendModes from '../../../enums/BlendModes';
+export function mapBlendModeToSlabType(blendMode) {
+    switch (blendMode) {
+        case BlendModes.MAXIMUM_INTENSITY_BLEND:
+            return SlabTypes.MAX;
+        case BlendModes.MINIMUM_INTENSITY_BLEND:
+            return SlabTypes.MIN;
+        case BlendModes.AVERAGE_INTENSITY_BLEND:
+        case BlendModes.COMPOSITE:
+            return SlabTypes.MEAN;
+        case BlendModes.LABELMAP_EDGE_PROJECTION_BLEND:
+            return SlabTypes.MAX;
+        default:
+            return;
+    }
+}
+export function mapSlabTypeToBlendMode(slabType) {
+    switch (slabType) {
+        case SlabTypes.MAX:
+            return BlendModes.MAXIMUM_INTENSITY_BLEND;
+        case SlabTypes.MIN:
+            return BlendModes.MINIMUM_INTENSITY_BLEND;
+        case SlabTypes.MEAN:
+            return BlendModes.AVERAGE_INTENSITY_BLEND;
+        default:
+            return BlendModes.COMPOSITE;
+    }
+}
+export function resolveSlabThickness(slabThickness) {
+    if (typeof slabThickness !== 'number' || slabThickness <= 0) {
+        return 0;
+    }
+    return Math.max(slabThickness, RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS);
+}

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

@@ -0,0 +1,12 @@
+import type { ICamera, Point2, Point3 } from '../../types';
+declare abstract class ResolvedViewportView<TState, TICamera extends ICamera<unknown> = ICamera> {
+    readonly state: Readonly<TState>;
+    private cachedICamera?;
+    constructor(state: TState);
+    abstract canvasToWorld(canvasPos: Point2): Point3;
+    abstract worldToCanvas(worldPos: Point3): Point2;
+    abstract getFrameOfReferenceUID(): string | undefined;
+    toICamera(): TICamera;
+    protected abstract buildICamera(): TICamera;
+}
+export default ResolvedViewportView;

package/dist/esm/RenderingEngine/GenericViewport/ResolvedViewportView.js

@@ -0,0 +1,10 @@
+class ResolvedViewportView {
+    constructor(state) {
+        this.state = Object.freeze(state);
+    }
+    toICamera() {
+        this.cachedICamera ||= this.buildICamera();
+        return this.cachedICamera;
+    }
+}
+export default ResolvedViewportView;

package/dist/esm/RenderingEngine/GenericViewport/Video/DefaultVideoDataProvider.d.ts

@@ -0,0 +1,5 @@
+import type { DataProvider, LoadedData } from '../ViewportArchitectureTypes';
+import type { VideoStreamPayload } from './VideoViewportTypes';
+export declare class DefaultVideoDataProvider implements DataProvider {
+    load(dataId: string): Promise<LoadedData<VideoStreamPayload>>;
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/DefaultVideoDataProvider.js

@@ -0,0 +1,18 @@
+import { loadVideoStreamMetadata } from '../../../utilities/VideoUtilities';
+import { getGenericViewportSourceDataId } from '../genericViewportDataSetAccess';
+export class DefaultVideoDataProvider {
+    async load(dataId) {
+        const sourceDataId = getGenericViewportSourceDataId(dataId);
+        const stream = loadVideoStreamMetadata(sourceDataId);
+        return {
+            id: dataId,
+            type: 'video',
+            renderedUrl: stream.renderedUrl,
+            fps: stream.cineRate || 30,
+            numberOfFrames: stream.numberOfFrames || 1,
+            frameRange: [1, stream.numberOfFrames || 1],
+            modality: stream.modality,
+            metadata: stream.metadata,
+        };
+    }
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/HtmlVideoRenderPath.d.ts

@@ -0,0 +1,19 @@
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import ViewportType from '../../../enums/ViewportType';
+import type { VideoDataPresentation, VideoElementRenderContext } from './VideoViewportTypes';
+export declare class HtmlVideoRenderPath implements RenderPath<VideoElementRenderContext> {
+    addData(ctx: VideoElementRenderContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<VideoDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private canvasToWorld;
+    private worldToCanvas;
+    private getCanvasMapping;
+    private getFrameOfReferenceUID;
+    private removeData;
+}
+export declare class HtmlVideoPath implements RenderPathDefinition<VideoElementRenderContext> {
+    readonly id = "video:html-element";
+    readonly type = ViewportType.VIDEO_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): HtmlVideoRenderPath;
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/HtmlVideoRenderPath.js

@@ -0,0 +1,141 @@
+import ViewportType from '../../../enums/ViewportType';
+import { normalizeVideoPlaybackInfo } from '../../../utilities/VideoUtilities';
+import { resolveVideoCanvasMapping } from './videoViewportCamera';
+export class HtmlVideoRenderPath {
+    async addData(ctx, data, options) {
+        const videoData = data;
+        const payload = videoData;
+        const element = document.createElement('video');
+        element.src = payload.renderedUrl;
+        element.preload = 'auto';
+        element.crossOrigin = 'anonymous';
+        element.playsInline = true;
+        element.style.position = 'absolute';
+        element.style.left = '0';
+        element.style.top = '0';
+        element.style.transformOrigin = 'top left';
+        element.style.objectFit = 'fill';
+        await new Promise((resolve) => {
+            const onLoadedMetadata = () => {
+                element.removeEventListener('loadedmetadata', onLoadedMetadata);
+                resolve();
+            };
+            element.addEventListener('loadedmetadata', onLoadedMetadata);
+            ctx.element.appendChild(element);
+        });
+        const playbackInfo = normalizeVideoPlaybackInfo({
+            durationSeconds: element.duration,
+            cineRate: payload.fps,
+            numberOfFrames: payload.numberOfFrames,
+        });
+        const normalizedPayload = {
+            ...payload,
+            durationSeconds: element.duration,
+            fps: playbackInfo.fps,
+            numberOfFrames: playbackInfo.numberOfFrames,
+            frameRange: playbackInfo.frameRange,
+        };
+        Object.assign(videoData, normalizedPayload);
+        const rendering = {
+            renderMode: 'video2d',
+            element,
+        };
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(rendering, camera, videoData);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(rendering);
+            },
+            removeData: () => {
+                this.removeData(rendering);
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        const videoProps = props;
+        const { element } = rendering;
+        element.style.display = videoProps?.visible === false ? 'none' : '';
+        element.style.opacity = String(videoProps?.opacity ?? 1);
+        element.loop = videoProps?.loop ?? true;
+        element.muted = videoProps?.muted ?? true;
+        element.playbackRate = videoProps?.playbackRate ?? 1;
+        element.style.objectFit = videoProps?.objectFit ?? 'contain';
+    }
+    applyViewState(rendering, camera, data) {
+        const videoCamera = camera;
+        const { element } = rendering;
+        const rotation = videoCamera.rotation ?? 0;
+        const mapping = this.getCanvasMapping(element, videoCamera);
+        rendering.currentCamera = videoCamera;
+        if (mapping) {
+            element.style.width = `${mapping.width}px`;
+            element.style.height = `${mapping.height}px`;
+            element.style.left = `${mapping.left}px`;
+            element.style.top = `${mapping.top}px`;
+        }
+        element.style.transform = `rotate(${rotation}deg)`;
+        if (typeof videoCamera.currentTimeSeconds === 'number' &&
+            Math.abs(element.currentTime - videoCamera.currentTimeSeconds) >
+                0.5 / Math.max(1, data.fps)) {
+            element.currentTime = videoCamera.currentTimeSeconds;
+        }
+    }
+    canvasToWorld(rendering, canvasPos) {
+        const mapping = this.getCanvasMapping(rendering.element, rendering.currentCamera);
+        if (!mapping) {
+            return [0, 0, 0];
+        }
+        return [
+            (canvasPos[0] - mapping.left) / mapping.worldToCanvasRatio,
+            (canvasPos[1] - mapping.top) / mapping.worldToCanvasRatio,
+            0,
+        ];
+    }
+    worldToCanvas(rendering, worldPos) {
+        const mapping = this.getCanvasMapping(rendering.element, rendering.currentCamera);
+        if (!mapping) {
+            return [0, 0];
+        }
+        return [
+            mapping.left + worldPos[0] * mapping.worldToCanvasRatio,
+            mapping.top + worldPos[1] * mapping.worldToCanvasRatio,
+        ];
+    }
+    getCanvasMapping(element, camera) {
+        const container = element.parentElement;
+        return resolveVideoCanvasMapping({
+            containerWidth: container?.clientWidth ?? 0,
+            containerHeight: container?.clientHeight ?? 0,
+            intrinsicWidth: element.videoWidth || container?.clientWidth || 0,
+            intrinsicHeight: element.videoHeight || container?.clientHeight || 0,
+            objectFit: element.style.objectFit,
+            camera,
+        });
+    }
+    getFrameOfReferenceUID(rendering) {
+        const { element } = rendering;
+        return element.currentSrc || element.src;
+    }
+    removeData(rendering) {
+        const { element } = rendering;
+        element.pause();
+        element.remove();
+    }
+}
+export class HtmlVideoPath {
+    constructor() {
+        this.id = 'video:html-element';
+        this.type = ViewportType.VIDEO_NEXT;
+    }
+    matches(data, options) {
+        return data.type === 'video' && options.renderMode === 'video2d';
+    }
+    createRenderPath() {
+        return new HtmlVideoRenderPath();
+    }
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoProjectionTypes.d.ts

@@ -0,0 +1,45 @@
+import { ViewportType } from '../../../enums';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot } from '../ViewportProjectionTypes';
+import type { VideoViewState } from './VideoViewportTypes';
+export declare const VIDEO_PROJECTION_ID = "video";
+export type VideoResolvedViewLike = {
+    state?: {
+        containerHeight?: number;
+        containerWidth?: number;
+        intrinsicHeight?: number;
+        intrinsicWidth?: number;
+        viewState: VideoViewState;
+    };
+    pan: Point2;
+    rotation: number;
+    zoom: number;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    toICamera(): ICamera;
+    withPan(pan: Point2): VideoResolvedViewLike;
+    withZoom(zoom: number, canvasPoint?: Point2): VideoResolvedViewLike;
+};
+export type VideoProjectionViewport = {
+    type: ViewportType | string;
+    element?: HTMLDivElement;
+    getFrameOfReferenceUID?(): string | undefined;
+    getResolvedView?(): VideoResolvedViewLike | undefined;
+    getViewState?(): VideoViewState;
+};
+export interface VideoProjectionPresentation extends ProjectionPresentation<never> {
+    rawPan: Point2;
+}
+export interface VideoProjectionSnapshot extends ProjectionSnapshot<VideoViewState, VideoProjectionPresentation> {
+    canvasHeight: number;
+    canvasWidth: number;
+    resolvedView?: VideoResolvedViewLike;
+}
+export interface VideoProjectionRequest extends ProjectionRequest<VideoProjectionViewport> {
+    canvasHeight?: number;
+    canvasWidth?: number;
+    frameOfReferenceUID?: string;
+    resolvedView?: VideoResolvedViewLike;
+    viewState?: VideoViewState;
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoProjectionTypes.js

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

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoRenderPathResolver.d.ts

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

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoRenderPathResolver.js

@@ -0,0 +1,8 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import { HtmlVideoPath } from './HtmlVideoRenderPath';
+export function createDefaultVideoRenderPaths() {
+    return [new HtmlVideoPath()];
+}
+export function createVideoRenderPathResolver(paths = createDefaultVideoRenderPaths()) {
+    return new DefaultRenderPathResolver(paths);
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoResolvedView.d.ts

@@ -0,0 +1,29 @@
+import type { ICamera, Point2, Point3 } from '../../../types';
+import ResolvedViewportView from '../ResolvedViewportView';
+import type { VideoViewState, VideoProperties, VideoStreamPayload } from './VideoViewportTypes';
+type VideoResolvedViewState = {
+    viewState: VideoViewState;
+    containerHeight: number;
+    containerWidth: number;
+    frameOfReferenceUID?: string;
+    intrinsicHeight: number;
+    intrinsicWidth: number;
+    objectFit?: VideoProperties['objectFit'];
+    payload?: VideoStreamPayload;
+};
+declare class VideoResolvedView extends ResolvedViewportView<VideoResolvedViewState> {
+    private cachedCanvasMapping?;
+    get zoom(): number;
+    get pan(): Point2;
+    get rotation(): number;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    withZoom(zoom: number, canvasPoint?: Point2): VideoResolvedView;
+    withPan(pan: Point2): VideoResolvedView;
+    protected buildICamera(): ICamera;
+    private getCanvasMapping;
+    private cloneWithViewState;
+}
+export type { VideoResolvedViewState };
+export default VideoResolvedView;