@cornerstonejs/core/dist/esm/RenderingEngine/helpers/renderBackendRegistry.js

Cornerstone3D Core

import RenderBackends, { registerRenderBackendsConstant, } from '../../enums/RenderBackends.js';
import { ActorRenderMode } from '../../types/IActor.js';
const backendDefinitions = new Map();
const renderModeIndex = new Map();
const registeredConstantNames = [];
let hasRegisteredCoreRenderBackends = false;
function registerCoreRenderBackends() {
    if (hasRegisteredCoreRenderBackends) {
        return;
    }
    hasRegisteredCoreRenderBackends = true;
    registerRenderBackend({
        backend: RenderBackends.GPU,
        renderModes: {
            image: { id: ActorRenderMode.VTK_IMAGE },
            volume: { id: ActorRenderMode.VTK_VOLUME_SLICE },
        },
        surface: 'vtk',
    });
    registerRenderBackend({
        backend: RenderBackends.CPU,
        renderModes: {
            image: { id: ActorRenderMode.CPU_IMAGE },
            volume: { id: ActorRenderMode.CPU_VOLUME },
        },
        surface: 'cpu',
    });
}
export function registerRenderBackend({ backend, name, renderModes, surface = 'vtk', }) {
    registerCoreRenderBackends();
    if (backend === RenderBackends.Auto) {
        throw new Error(`Render backend id "${RenderBackends.Auto}" is reserved for the automatic backend resolution`);
    }
    if (backendDefinitions.has(backend)) {
        throw new Error(`Render backend "${backend}" is already registered`);
    }
    if (!renderModes?.image?.id) {
        throw new Error(`Render backend "${backend}" must declare renderModes.image`);
    }
    if (renderModes.volume && renderModes.volume.id === renderModes.image.id) {
        throw new Error(`Render backend "${backend}" must use distinct render modes for image and volume`);
    }
    const modeEntries = [
        [renderModes.image.id, 'image'],
    ];
    if (renderModes.volume) {
        modeEntries.push([renderModes.volume.id, 'volume']);
    }
    for (const [renderMode] of modeEntries) {
        const existing = renderModeIndex.get(renderMode);
        if (existing && existing.backend !== backend) {
            throw new Error(`Render mode "${renderMode}" is already provided by render backend "${existing.backend}"`);
        }
    }
    if (name && Object.prototype.hasOwnProperty.call(RenderBackends, name)) {
        throw new Error(`Render backend constant "${String(name)}" already exists`);
    }
    backendDefinitions.set(backend, {
        backend,
        renderModes,
        surface,
    });
    for (const [renderMode, kind] of modeEntries) {
        renderModeIndex.set(renderMode, {
            backend: backend,
            kind,
            surface,
        });
    }
    if (name) {
        registerRenderBackendsConstant(name, backend);
        registeredConstantNames.push(name);
    }
}
export function isRegisteredRenderBackend(backend) {
    registerCoreRenderBackends();
    return backendDefinitions.has(backend);
}
export function getRenderBackendDefinition(backend) {
    registerCoreRenderBackends();
    return backendDefinitions.get(backend);
}
export function getRenderModeForBackend(backend, kind) {
    const definition = getRenderBackendDefinition(backend);
    if (!definition) {
        throw new Error(`Unknown render backend "${backend}". Register it with registerRenderBackend() first.`);
    }
    const renderMode = definition.renderModes[kind];
    if (!renderMode) {
        throw new Error(`Render backend "${backend}" does not support ${kind}-backed rendering`);
    }
    return renderMode.id;
}
export function getRenderBackendForRenderMode(renderMode) {
    registerCoreRenderBackends();
    return renderMode ? renderModeIndex.get(renderMode)?.backend : undefined;
}
export function isVolumeRenderMode(renderMode) {
    registerCoreRenderBackends();
    return renderMode
        ? renderModeIndex.get(renderMode)?.kind === 'volume'
        : false;
}
export function isImageRenderMode(renderMode) {
    registerCoreRenderBackends();
    return renderMode ? renderModeIndex.get(renderMode)?.kind === 'image' : false;
}
export function getRenderSurfaceForRenderMode(renderMode) {
    registerCoreRenderBackends();
    return (renderMode && renderModeIndex.get(renderMode)?.surface) || 'vtk';
}
export function createRegisteredPlanarRenderPaths() {
    registerCoreRenderBackends();
    const paths = [];
    for (const definition of backendDefinitions.values()) {
        const { image, volume } = definition.renderModes;
        for (const mode of [image, volume]) {
            if (mode?.createDefinition) {
                paths.push(mode.createDefinition());
            }
        }
    }
    return paths;
}
export function __resetRenderBackendRegistry() {
    backendDefinitions.clear();
    renderModeIndex.clear();
    hasRegisteredCoreRenderBackends = false;
    for (const name of registeredConstantNames) {
        delete RenderBackends[name];
    }
    registeredConstantNames.length = 0;
}