@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/RenderingEngine/helpers/stats/StatsOverlay.js

@@ -1,17 +1,25 @@
+import renderingEngineCache from '../../renderingEngineCache';
+import { RenderModesPanel, } from './RenderModesPanel';
 import { StatsPanel } from './StatsPanel';
 import { PanelType } from './enums';
 import { STATS_CONFIG, PANEL_CONFIGS, CONVERSION } from './constants';
 export class StatsOverlay {
-    static { this.instance = null; }
     constructor() {
         this.dom = null;
-        this.currentMode = 0;
         this.startTime = 0;
         this.lastUpdateTime = 0;
         this.frameCount = 0;
         this.panels = new Map();
+        this.metricsColumn = null;
+        this.bindingsColumn = null;
         this.animationFrameId = null;
         this.isSetup = false;
+        this.dragPointerId = null;
+        this.dragOffsetX = 0;
+        this.dragOffsetY = 0;
+        this.handlePointerDown = (event) => this.onPointerDown(event);
+        this.handlePointerMove = (event) => this.onPointerMove(event);
+        this.handlePointerUp = (event) => this.onPointerUp(event);
     }
     static getInstance() {
         if (!StatsOverlay.instance) {
@@ -28,8 +36,9 @@ export class StatsOverlay {
             this.startTime = performance.now();
             this.lastUpdateTime = this.startTime;
             this.initializePanels();
-            this.showPanel(PanelType.FPS);
             this.applyOverlayStyles();
+            this.restorePosition();
+            this.attachDragHandlers();
             document.body.appendChild(this.dom);
             this.startLoop();
             this.isSetup = true;
@@ -40,37 +49,29 @@ export class StatsOverlay {
     }
     cleanup() {
         this.stopLoop();
+        this.detachDragHandlers();
         if (this.dom && this.dom.parentNode) {
             this.dom.parentNode.removeChild(this.dom);
         }
         this.dom = null;
+        this.metricsColumn = null;
+        this.bindingsColumn = null;
         this.panels.clear();
         this.isSetup = false;
     }
-    showPanel(panelType) {
-        const children = Array.from(this.dom.children);
-        children.forEach((child, index) => {
-            child.style.display = index === panelType ? 'block' : 'none';
-        });
-        this.currentMode = panelType;
+    showPanel(_panelType) {
     }
     update() {
         this.startTime = this.updateStats();
     }
     createOverlayElement() {
-        const element = document.createElement('div');
-        element.addEventListener('click', this.handleClick.bind(this), false);
-        return element;
+        return document.createElement('div');
     }
     applyOverlayStyles() {
         Object.assign(this.dom.style, STATS_CONFIG.OVERLAY_STYLES);
     }
-    handleClick(event) {
-        event.preventDefault();
-        const panelCount = this.dom.children.length;
-        this.showPanel((this.currentMode + 1) % panelCount);
-    }
     initializePanels() {
+        this.initializePanelColumns();
         const fpsPanel = new StatsPanel(PANEL_CONFIGS[PanelType.FPS].name, PANEL_CONFIGS[PanelType.FPS].foregroundColor, PANEL_CONFIGS[PanelType.FPS].backgroundColor);
         this.addPanel(PanelType.FPS, fpsPanel);
         const msPanel = new StatsPanel(PANEL_CONFIGS[PanelType.MS].name, PANEL_CONFIGS[PanelType.MS].foregroundColor, PANEL_CONFIGS[PanelType.MS].backgroundColor);
@@ -79,13 +80,34 @@ export class StatsOverlay {
             const memPanel = new StatsPanel(PANEL_CONFIGS[PanelType.MEMORY].name, PANEL_CONFIGS[PanelType.MEMORY].foregroundColor, PANEL_CONFIGS[PanelType.MEMORY].backgroundColor);
             this.addPanel(PanelType.MEMORY, memPanel);
         }
+        this.addPanel(PanelType.RENDER_MODES, new RenderModesPanel());
+    }
+    initializePanelColumns() {
+        this.metricsColumn = document.createElement('div');
+        this.metricsColumn.style.cssText = `
+      display:flex;
+      flex-direction:column;
+      flex:0 0 auto;
+    `;
+        this.bindingsColumn = document.createElement('div');
+        this.bindingsColumn.style.cssText = `
+      display:flex;
+      flex-direction:column;
+      flex:0 1 auto;
+      min-width:0;
+    `;
+        this.dom.appendChild(this.metricsColumn);
+        this.dom.appendChild(this.bindingsColumn);
     }
     isMemoryAvailable() {
         const perf = performance;
         return perf.memory !== undefined;
     }
     addPanel(type, panel) {
-        this.dom.appendChild(panel.dom);
+        const column = type === PanelType.RENDER_MODES
+            ? this.bindingsColumn
+            : this.metricsColumn;
+        (column ?? this.dom).appendChild(panel.dom);
         this.panels.set(type, panel);
     }
     startLoop() {
@@ -119,9 +141,49 @@ export class StatsOverlay {
             this.lastUpdateTime = currentTime;
             this.frameCount = 0;
             this.updateMemoryPanel();
+            this.updateRenderModesPanel();
         }
         return currentTime;
     }
+    updateRenderModesPanel() {
+        const panel = this.panels.get(PanelType.RENDER_MODES);
+        if (!(panel instanceof RenderModesPanel)) {
+            return;
+        }
+        const entries = [];
+        for (const renderingEngine of renderingEngineCache.getAll()) {
+            if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+                continue;
+            }
+            for (const viewport of renderingEngine.getViewports()) {
+                const debugViewport = viewport;
+                const renderModes = debugViewport._debug?.renderModes;
+                entries.push({
+                    renderingEngineId: renderingEngine.id,
+                    viewportId: viewport.id,
+                    bindings: this.getViewportBindingDebugEntries(debugViewport, renderModes ?? {}),
+                });
+            }
+        }
+        panel.setContent(entries);
+    }
+    getViewportBindingDebugEntries(viewport, renderModes) {
+        const actors = viewport.getActors?.() ?? [];
+        const sourceDataId = viewport.getSourceDataId?.();
+        return Object.entries(renderModes).map(([dataId, renderMode]) => {
+            const role = resolveBindingRole(viewport, dataId, sourceDataId);
+            const actor = role === 'source'
+                ? viewport.getDefaultActor?.()
+                : findActorForDataId(actors, dataId);
+            return {
+                actorUID: actor?.uid,
+                dataId,
+                referencedId: actor?.referencedId,
+                renderMode,
+                role,
+            };
+        });
+    }
     updateMemoryPanel() {
         const memPanel = this.panels.get(PanelType.MEMORY);
         if (!memPanel) {
@@ -134,4 +196,116 @@ export class StatsOverlay {
             memPanel.update(memoryMB, maxMemoryMB);
         }
     }
+    attachDragHandlers() {
+        this.dom?.addEventListener('pointerdown', this.handlePointerDown);
+    }
+    detachDragHandlers() {
+        this.dom?.removeEventListener('pointerdown', this.handlePointerDown);
+        window.removeEventListener('pointermove', this.handlePointerMove);
+        window.removeEventListener('pointerup', this.handlePointerUp);
+        window.removeEventListener('pointercancel', this.handlePointerUp);
+    }
+    onPointerDown(event) {
+        if (!this.dom || event.button !== 0) {
+            return;
+        }
+        this.dragPointerId = event.pointerId;
+        const rect = this.dom.getBoundingClientRect();
+        this.dragOffsetX = event.clientX - rect.left;
+        this.dragOffsetY = event.clientY - rect.top;
+        this.setPosition(rect.left, rect.top);
+        window.addEventListener('pointermove', this.handlePointerMove);
+        window.addEventListener('pointerup', this.handlePointerUp);
+        window.addEventListener('pointercancel', this.handlePointerUp);
+        event.preventDefault();
+    }
+    onPointerMove(event) {
+        if (this.dragPointerId !== event.pointerId || !this.dom) {
+            return;
+        }
+        this.setPosition(event.clientX - this.dragOffsetX, event.clientY - this.dragOffsetY);
+    }
+    onPointerUp(event) {
+        if (this.dragPointerId !== event.pointerId || !this.dom) {
+            return;
+        }
+        this.dragPointerId = null;
+        window.removeEventListener('pointermove', this.handlePointerMove);
+        window.removeEventListener('pointerup', this.handlePointerUp);
+        window.removeEventListener('pointercancel', this.handlePointerUp);
+        const rect = this.dom.getBoundingClientRect();
+        this.savePosition(rect.left, rect.top);
+    }
+    setPosition(left, top) {
+        if (!this.dom) {
+            return;
+        }
+        const clamped = this.clampToViewport(left, top);
+        this.dom.style.left = `${clamped.left}px`;
+        this.dom.style.top = `${clamped.top}px`;
+        this.dom.style.right = 'auto';
+        this.dom.style.bottom = 'auto';
+    }
+    clampToViewport(left, top) {
+        if (!this.dom) {
+            return { left, top };
+        }
+        const width = this.dom.offsetWidth;
+        const height = this.dom.offsetHeight;
+        const maxLeft = Math.max(0, window.innerWidth - width);
+        const maxTop = Math.max(0, window.innerHeight - height);
+        return {
+            left: Math.min(Math.max(0, left), maxLeft),
+            top: Math.min(Math.max(0, top), maxTop),
+        };
+    }
+    restorePosition() {
+        const saved = this.readSavedPosition();
+        if (!saved) {
+            return;
+        }
+        this.setPosition(saved.left, saved.top);
+    }
+    readSavedPosition() {
+        try {
+            const raw = window.localStorage.getItem(STATS_CONFIG.POSITION_STORAGE_KEY);
+            if (!raw) {
+                return null;
+            }
+            const parsed = JSON.parse(raw);
+            if (typeof parsed?.left !== 'number' ||
+                typeof parsed?.top !== 'number' ||
+                !Number.isFinite(parsed.left) ||
+                !Number.isFinite(parsed.top)) {
+                return null;
+            }
+            return { left: parsed.left, top: parsed.top };
+        }
+        catch {
+            return null;
+        }
+    }
+    savePosition(left, top) {
+        try {
+            window.localStorage.setItem(STATS_CONFIG.POSITION_STORAGE_KEY, JSON.stringify({ left, top }));
+        }
+        catch {
+        }
+    }
+}
+StatsOverlay.instance = null;
+function resolveBindingRole(viewport, dataId, sourceDataId) {
+    const role = viewport.getDisplaySetRole?.(dataId);
+    if (role === 'source' || role === 'overlay') {
+        return role;
+    }
+    if (sourceDataId && dataId === sourceDataId) {
+        return 'source';
+    }
+    return 'data';
+}
+function findActorForDataId(actors, dataId) {
+    return actors.find((actor) => actor.uid === dataId ||
+        actor.representationUID === dataId ||
+        actor.referencedId === dataId);
 }

package/dist/esm/RenderingEngine/helpers/stats/constants.d.ts

@@ -1,5 +1,6 @@
 declare const PANEL_CONFIG: {
     readonly WIDTH: 160;
+    readonly WIDE_WIDTH: 360;
     readonly HEIGHT: 96;
     readonly TEXT_PADDING: 3;
     readonly TEXT_Y_OFFSET: 2;
@@ -20,9 +21,16 @@ declare const STATS_CONFIG: {
         readonly right: "0px";
         readonly left: "auto";
         readonly zIndex: "9999";
-        readonly cursor: "pointer";
+        readonly cursor: "move";
         readonly opacity: "0.9";
+        readonly display: "flex";
+        readonly flexDirection: "row";
+        readonly alignItems: "flex-start";
+        readonly gap: "4px";
+        readonly maxWidth: "calc(100vw - 8px)";
+        readonly userSelect: "none";
     };
+    readonly POSITION_STORAGE_KEY: "cornerstone-stats-overlay-position";
 };
 declare const CONVERSION: {
     readonly BYTES_TO_MB: 1048576;
@@ -40,5 +48,9 @@ declare const PANEL_CONFIGS: readonly [{
     readonly name: "MB";
     readonly foregroundColor: "#f08";
     readonly backgroundColor: "#201";
+}, {
+    readonly name: "VIEWPORT BINDINGS";
+    readonly foregroundColor: "#fc0";
+    readonly backgroundColor: "#221100";
 }];
 export { PANEL_CONFIG, STATS_CONFIG, CONVERSION, PANEL_CONFIGS };

package/dist/esm/RenderingEngine/helpers/stats/constants.js

@@ -1,5 +1,6 @@
 const PANEL_CONFIG = {
     WIDTH: 160,
+    WIDE_WIDTH: 360,
     HEIGHT: 96,
     TEXT_PADDING: 3,
     TEXT_Y_OFFSET: 2,
@@ -20,9 +21,16 @@ const STATS_CONFIG = {
         right: '0px',
         left: 'auto',
         zIndex: '9999',
-        cursor: 'pointer',
+        cursor: 'move',
         opacity: '0.9',
+        display: 'flex',
+        flexDirection: 'row',
+        alignItems: 'flex-start',
+        gap: '4px',
+        maxWidth: 'calc(100vw - 8px)',
+        userSelect: 'none',
     },
+    POSITION_STORAGE_KEY: 'cornerstone-stats-overlay-position',
 };
 const CONVERSION = {
     BYTES_TO_MB: 1048576,
@@ -32,5 +40,10 @@ const PANEL_CONFIGS = [
     { name: 'FPS', foregroundColor: '#0ff', backgroundColor: '#002' },
     { name: 'MS', foregroundColor: '#0f0', backgroundColor: '#020' },
     { name: 'MB', foregroundColor: '#f08', backgroundColor: '#201' },
+    {
+        name: 'VIEWPORT BINDINGS',
+        foregroundColor: '#fc0',
+        backgroundColor: '#221100',
+    },
 ];
 export { PANEL_CONFIG, STATS_CONFIG, CONVERSION, PANEL_CONFIGS };

package/dist/esm/RenderingEngine/helpers/stats/enums.d.ts

@@ -1,6 +1,7 @@
 declare enum PanelType {
     FPS = 0,
     MS = 1,
-    MEMORY = 2
+    MEMORY = 2,
+    RENDER_MODES = 3
 }
 export { PanelType };

package/dist/esm/RenderingEngine/helpers/stats/enums.js

@@ -3,5 +3,6 @@ var PanelType;
     PanelType[PanelType["FPS"] = 0] = "FPS";
     PanelType[PanelType["MS"] = 1] = "MS";
     PanelType[PanelType["MEMORY"] = 2] = "MEMORY";
+    PanelType[PanelType["RENDER_MODES"] = 3] = "RENDER_MODES";
 })(PanelType || (PanelType = {}));
 export { PanelType };

package/dist/esm/RenderingEngine/helpers/stats/types.d.ts

@@ -1,5 +1,5 @@
 interface Panel {
-    dom: HTMLCanvasElement;
+    dom: HTMLElement;
     update: (value: number, maxValue: number) => void;
 }
 interface StatsInstance {

package/dist/esm/RenderingEngine/helpers/supportsVolumeCompatibilityApi.d.ts

@@ -0,0 +1,4 @@
+import type { IVolumeViewport } from '../../types';
+export type ICompatibleVolumeViewport = Pick<IVolumeViewport, 'setVolumes' | 'addVolumes'>;
+declare function isVolumeCompatible(viewport: unknown): viewport is ICompatibleVolumeViewport;
+export default isVolumeCompatible;

package/dist/esm/RenderingEngine/helpers/supportsVolumeCompatibilityApi.js

@@ -0,0 +1,7 @@
+function isVolumeCompatible(viewport) {
+    return Boolean(viewport &&
+        typeof viewport.setVolumes ===
+            'function' &&
+        typeof viewport.addVolumes === 'function');
+}
+export default isVolumeCompatible;

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.d.ts

@@ -1,8 +1,31 @@
-import type { ViewportInput, IViewport } from '../../types/IViewport';
+import type { ViewportType as ViewportTypeWire } from '../../types/ViewportTypeRegistry';
+import ECGViewport from '../GenericViewport/ECG/ECGViewport';
+import PlanarViewport from '../GenericViewport/Planar/PlanarViewport';
+import NextVideoViewport from '../GenericViewport/Video/VideoViewport';
+import VolumeViewport3D from '../GenericViewport/Volume3D/viewport3D';
+import type { ViewportTypeConstants } from '../../types/ViewportTypeRegistry';
+import type { ViewportInput, IViewport, InternalViewportInput, NormalizedViewportInput } from '../../types/IViewport';
 interface ViewportConstructor {
-    new (viewportInput: ViewportInput): IViewport;
+    new (viewportInput: ViewportInput): IViewport | PlanarViewport | NextVideoViewport | VolumeViewport3D | ECGViewport;
+    useCustomRenderingPipeline?: boolean;
 }
-declare const viewportTypeToViewportClass: {
-    [key: string]: ViewportConstructor;
+type ViewportClassInput = Pick<ViewportInput | InternalViewportInput | NormalizedViewportInput, 'type' | 'requestedType'>;
+type ViewportClassResolver = (input: ViewportClassInput) => ViewportConstructor | undefined;
+type RegisterViewportTypeBaseOptions = {
+    ViewportClass: ViewportConstructor;
+    resolveClass?: ViewportClassResolver;
 };
+type RegisterViewportTypeNamedOptions<Name extends keyof ViewportTypeConstants> = RegisterViewportTypeBaseOptions & {
+    name: Name;
+    type: ViewportTypeConstants[Name];
+};
+type RegisterViewportTypeUnnamedOptions = RegisterViewportTypeBaseOptions & {
+    type: ViewportTypeWire | string;
+    name?: never;
+};
+declare const viewportTypeToViewportClass: Record<string, ViewportConstructor>;
+export declare function registerViewportType<Name extends keyof ViewportTypeConstants>(options: RegisterViewportTypeNamedOptions<Name>): void;
+export declare function registerViewportType(options: RegisterViewportTypeUnnamedOptions): void;
+export declare function isRegisteredViewportType(type: string): boolean;
 export default viewportTypeToViewportClass;
+export declare function getViewportClassForInput(input: ViewportClassInput): ViewportConstructor;

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.js

@@ -1,17 +1,132 @@
 import StackViewport from '../StackViewport';
 import VolumeViewport from '../VolumeViewport';
 import ViewportType from '../../enums/ViewportType';
-import VolumeViewport3D from '../VolumeViewport3D';
+import ViewportTypes, { registerViewportTypesConstant, } from '../../enums/ViewportTypes';
+import LegacyVolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
 import WSIViewport from '../WSIViewport';
-import ECGViewport from '../ECGViewport';
-const viewportTypeToViewportClass = {
-    [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
-    [ViewportType.PERSPECTIVE]: VolumeViewport,
-    [ViewportType.STACK]: StackViewport,
-    [ViewportType.VOLUME_3D]: VolumeViewport3D,
-    [ViewportType.VIDEO]: VideoViewport,
-    [ViewportType.WHOLE_SLIDE]: WSIViewport,
-    [ViewportType.ECG]: ECGViewport,
-};
+import LegacyECGViewport from '../ECGViewport';
+import ECGViewport from '../GenericViewport/ECG/ECGViewport';
+import PlanarViewport from '../GenericViewport/Planar/PlanarViewport';
+import PlanarViewportLegacyAdapter from '../GenericViewport/Planar/PlanarViewportLegacyAdapter';
+import NextVideoViewport from '../GenericViewport/Video/VideoViewport';
+import VideoViewportLegacyAdapter from '../GenericViewport/Video/VideoViewportLegacyAdapter';
+import VolumeViewport3D from '../GenericViewport/Volume3D/viewport3D';
+import VolumeViewport3DLegacyAdapter from '../GenericViewport/Volume3D/VolumeViewport3DLegacyAdapter';
+import NextWSIViewport from '../GenericViewport/WSI/WSIViewport';
+import WSIViewportLegacyAdapter from '../GenericViewport/WSI/WSIViewportLegacyAdapter';
+import ECGViewportLegacyAdapter from '../GenericViewport/ECG/ECGViewportLegacyAdapter';
+const viewportConstructors = new Map();
+const viewportTypeToViewportClass = {};
+const resolvers = [];
+const registeredViewportTypes = new Set();
+let hasRegisteredCoreViewportTypes = false;
+function registerCoreViewportTypes() {
+    if (hasRegisteredCoreViewportTypes) {
+        return;
+    }
+    hasRegisteredCoreViewportTypes = true;
+    registerViewportType({
+        type: ViewportType.ORTHOGRAPHIC,
+        ViewportClass: VolumeViewport,
+    });
+    registerViewportType({
+        type: ViewportType.PERSPECTIVE,
+        ViewportClass: VolumeViewport,
+    });
+    registerViewportType({
+        type: ViewportType.STACK,
+        ViewportClass: StackViewport,
+    });
+    registerViewportType({
+        type: ViewportType.VOLUME_3D,
+        ViewportClass: LegacyVolumeViewport3D,
+    });
+    registerViewportType({
+        type: ViewportType.WHOLE_SLIDE,
+        ViewportClass: WSIViewport,
+    });
+    registerViewportType({
+        type: ViewportType.ECG,
+        ViewportClass: LegacyECGViewport,
+    });
+    registerViewportType({
+        type: ViewportType.VIDEO,
+        ViewportClass: VideoViewport,
+    });
+    registerViewportType({
+        type: ViewportType.VOLUME_3D_NEXT,
+        ViewportClass: VolumeViewport3D,
+        resolveClass: ({ type, requestedType }) => type === ViewportType.VOLUME_3D_NEXT &&
+            requestedType === ViewportType.VOLUME_3D
+            ? VolumeViewport3DLegacyAdapter
+            : undefined,
+    });
+    registerViewportType({
+        type: ViewportType.PLANAR_NEXT,
+        ViewportClass: PlanarViewport,
+        resolveClass: ({ type, requestedType }) => type === ViewportType.PLANAR_NEXT &&
+            (requestedType === ViewportType.STACK ||
+                requestedType === ViewportType.ORTHOGRAPHIC)
+            ? PlanarViewportLegacyAdapter
+            : undefined,
+    });
+    registerViewportType({
+        type: ViewportType.VIDEO_NEXT,
+        ViewportClass: NextVideoViewport,
+        resolveClass: ({ type, requestedType }) => type === ViewportType.VIDEO_NEXT && requestedType === ViewportType.VIDEO
+            ? VideoViewportLegacyAdapter
+            : undefined,
+    });
+    registerViewportType({
+        type: ViewportType.ECG_NEXT,
+        ViewportClass: ECGViewport,
+        resolveClass: ({ type, requestedType }) => type === ViewportType.ECG_NEXT && requestedType === ViewportType.ECG
+            ? ECGViewportLegacyAdapter
+            : undefined,
+    });
+    registerViewportType({
+        type: ViewportType.WHOLE_SLIDE_NEXT,
+        ViewportClass: NextWSIViewport,
+        resolveClass: ({ type, requestedType }) => type === ViewportType.WHOLE_SLIDE_NEXT &&
+            requestedType === ViewportType.WHOLE_SLIDE
+            ? WSIViewportLegacyAdapter
+            : undefined,
+    });
+}
+export function registerViewportType({ type, name, ViewportClass, resolveClass, }) {
+    if (viewportConstructors.has(type)) {
+        throw new Error(`Viewport type "${type}" is already registered`);
+    }
+    if (name && Object.prototype.hasOwnProperty.call(ViewportTypes, name)) {
+        throw new Error(`Viewport type constant "${name}" already exists`);
+    }
+    viewportConstructors.set(type, ViewportClass);
+    viewportTypeToViewportClass[type] = ViewportClass;
+    registeredViewportTypes.add(type);
+    if (name) {
+        registerViewportTypesConstant(name, type);
+    }
+    if (resolveClass) {
+        resolvers.push(resolveClass);
+    }
+}
+export function isRegisteredViewportType(type) {
+    registerCoreViewportTypes();
+    return registeredViewportTypes.has(type);
+}
 export default viewportTypeToViewportClass;
+export function getViewportClassForInput(input) {
+    registerCoreViewportTypes();
+    for (const resolveClass of resolvers) {
+        const resolved = resolveClass(input);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    const viewportClass = viewportConstructors.get(input.type);
+    if (!viewportClass) {
+        throw new Error(`Unknown viewport type: ${input.type}`);
+    }
+    return viewportClass;
+}

package/dist/esm/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.d.ts

@@ -1 +1,3 @@
-export default function viewportTypeUsesCustomRenderingPipeline(viewportType: string): any;
+import type { IViewport } from '../../types';
+export default function viewportTypeUsesCustomRenderingPipeline(viewportType: string): boolean;
+export declare function viewportUsesCustomRenderingPipeline(viewport: IViewport): boolean;

package/dist/esm/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.js

@@ -1,4 +1,11 @@
-import viewportTypeToViewportClass from './viewportTypeToViewportClass';
+import { getViewportClassForInput, isRegisteredViewportType, } from './viewportTypeToViewportClass';
 export default function viewportTypeUsesCustomRenderingPipeline(viewportType) {
-    return viewportTypeToViewportClass[viewportType].useCustomRenderingPipeline;
+    if (!isRegisteredViewportType(viewportType)) {
+        return false;
+    }
+    return Boolean(getViewportClassForInput({ type: viewportType })
+        .useCustomRenderingPipeline);
+}
+export function viewportUsesCustomRenderingPipeline(viewport) {
+    return viewport.getUseCustomRenderingPipeline();
 }

package/dist/esm/RenderingEngine/helpers/vtkCanvasCoordinateTransforms.d.ts

@@ -0,0 +1,12 @@
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type { Point2, Point3 } from '../../types';
+export declare function canvasToWorldContextPool(args: {
+    canvas: HTMLCanvasElement;
+    renderer: vtkRenderer;
+    canvasPos: Point2;
+}): Point3;
+export declare function worldToCanvasContextPool(args: {
+    canvas: HTMLCanvasElement;
+    renderer: vtkRenderer;
+    worldPos: Point3;
+}): Point2;

package/dist/esm/RenderingEngine/helpers/vtkCanvasCoordinateTransforms.js

@@ -0,0 +1,57 @@
+export function canvasToWorldContextPool(args) {
+    const { canvas, renderer, canvasPos } = args;
+    const vtkCamera = renderer.getActiveCamera();
+    const restoreCamera = prepareCameraForCoordinateTransforms(vtkCamera);
+    const devicePixelRatio = window.devicePixelRatio || 1;
+    const { width, height } = canvas;
+    const aspectRatio = width / height;
+    const canvasPosWithDPR = [
+        canvasPos[0] * devicePixelRatio,
+        canvasPos[1] * devicePixelRatio,
+    ];
+    const [xStart, yStart, xEnd, yEnd] = renderer.getViewport();
+    const viewportWidth = xEnd - xStart;
+    const viewportHeight = yEnd - yStart;
+    const normalizedDisplay = [
+        xStart + (canvasPosWithDPR[0] / width) * viewportWidth,
+        yStart + (1 - canvasPosWithDPR[1] / height) * viewportHeight,
+        0,
+    ];
+    const projCoords = renderer.normalizedDisplayToProjection(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2]);
+    const viewCoords = renderer.projectionToView(projCoords[0], projCoords[1], projCoords[2], aspectRatio);
+    const worldCoord = renderer.viewToWorld(viewCoords[0], viewCoords[1], viewCoords[2]);
+    restoreCamera();
+    return [worldCoord[0], worldCoord[1], worldCoord[2]];
+}
+export function worldToCanvasContextPool(args) {
+    const { canvas, renderer, worldPos } = args;
+    const vtkCamera = renderer.getActiveCamera();
+    const restoreCamera = prepareCameraForCoordinateTransforms(vtkCamera);
+    const devicePixelRatio = window.devicePixelRatio || 1;
+    const { width, height } = canvas;
+    const aspectRatio = width / height;
+    const viewCoords = renderer.worldToView(worldPos[0], worldPos[1], worldPos[2]);
+    const projCoords = renderer.viewToProjection(viewCoords[0], viewCoords[1], viewCoords[2], aspectRatio);
+    const normalizedDisplay = renderer.projectionToNormalizedDisplay(projCoords[0], projCoords[1], projCoords[2]);
+    const [xStart, yStart, xEnd, yEnd] = renderer.getViewport();
+    const viewportWidth = xEnd - xStart;
+    const viewportHeight = yEnd - yStart;
+    const canvasX = ((normalizedDisplay[0] - xStart) / viewportWidth) * width;
+    const canvasY = (1 - (normalizedDisplay[1] - yStart) / viewportHeight) * height;
+    restoreCamera();
+    return [canvasX / devicePixelRatio, canvasY / devicePixelRatio];
+}
+function prepareCameraForCoordinateTransforms(vtkCamera) {
+    if (vtkCamera.setIsPerformingCoordinateTransformation) {
+        vtkCamera.setIsPerformingCoordinateTransformation(true);
+        return () => {
+            vtkCamera.setIsPerformingCoordinateTransformation?.(false);
+        };
+    }
+    const clippingRange = vtkCamera.getClippingRange();
+    const distance = vtkCamera.getDistance();
+    vtkCamera.setClippingRange(distance, distance + 0.1);
+    return () => {
+        vtkCamera.setClippingRange(clippingRange[0], clippingRange[1]);
+    };
+}