@cornerstonejs/core/dist/esm/utilities/loadImageToCanvas.js

Cornerstone3D Core

import { loadAndCacheImage } from '../loaders/imageLoader.js';
import * as metaData from '../metaData.js';
import { MetadataModules, RequestType } from '../enums/index.js';
import imageLoadPoolManager from '../requestPool/imageLoadPoolManager.js';
import renderToCanvasGPU from './renderToCanvasGPU.js';
import renderToCanvasCPU from './renderToCanvasCPU.js';
import cache from '../cache/cache.js';
export default function loadImageToCanvas(options) {
    const { canvas, imageId, viewReference, requestType = RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
    const volumeId = viewReference?.volumeId;
    const isVolume = volumeId && !imageId;
    const viewportOptions = viewReference && baseViewportOptions
        ? { ...baseViewportOptions, viewReference }
        : baseViewportOptions;
    const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
    return new Promise((resolve, reject) => {
        function successCallback(imageOrVolume, imageId) {
            const { modality } = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
            const image = !isVolume && imageOrVolume;
            const volume = isVolume && imageOrVolume;
            if (image) {
                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
            }
            if (thumbnail) {
                canvas.height = 256;
                canvas.width = 256;
            }
            if (imageAspect && image) {
                canvas.width = image && (canvas.height * image.width) / image.height;
            }
            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
            if (volume && useCPURendering) {
                reject(new Error('CPU rendering of volume not supported'));
            }
            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
        }
        function errorCallback(error, imageId) {
            console.error(error, imageId);
            reject(error);
        }
        function sendRequest(imageId, imageIdIndex, options) {
            return loadAndCacheImage(imageId, options).then((image) => {
                successCallback.call(this, image, imageId);
            }, (error) => {
                errorCallback.call(this, error, imageId);
            });
        }
        const options = {
            useRGBA: !!useCPURendering,
            requestType,
        };
        if (volumeId) {
            const volume = cache.getVolume(volumeId);
            if (!volume) {
                reject(new Error(`Volume id ${volumeId} not found in cache`));
            }
            const useImageId = volume.imageIds[0];
            successCallback(volume, useImageId);
        }
        else {
            imageLoadPoolManager.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
        }
    });
}