@cornerstonejs/core/dist/esm/RenderingEngine/GenericViewport/Planar/DefaultPlanarDataProvider.js

Cornerstone3D Core

import { loadAndCacheImage } from '../../../loaders/imageLoader.js';
import { createAndCacheVolume } from '../../../loaders/volumeLoader.js';
import { ActorRenderMode } from '../../../types/index.js';
import resolveViewportVolumeId from '../../helpers/resolveViewportVolumeId.js';
import { getGenericViewportPlanarDisplaySet } from '../genericViewportDisplaySetAccess.js';
export class DefaultPlanarDataProvider {
    async load(dataId, options) {
        const dataSet = this.getDataSet(dataId);
        if (!dataSet) {
            throw new Error(`[PlanarViewport] No registered planar dataset for ${dataId}`);
        }
        if (!options) {
            throw new Error(`[PlanarViewport] No load options were provided for ${dataId}`);
        }
        if (!dataSet.imageIds.length) {
            throw new Error('[PlanarViewport] Cannot load an empty planar dataset');
        }
        const clampedImageIdIndex = Math.min(Math.max(0, dataSet.initialImageIdIndex ?? 0), dataSet.imageIds.length - 1);
        const initialImageIdIndex = dataSet.initialImageIdIndex === undefined
            ? undefined
            : clampedImageIdIndex;
        if (options.renderMode === ActorRenderMode.VTK_VOLUME_SLICE ||
            options.renderMode === ActorRenderMode.CPU_VOLUME) {
            const volumeId = resolveViewportVolumeId(options.volumeId);
            const imageVolume = await createAndCacheVolume(volumeId, {
                imageIds: dataSet.imageIds,
            });
            imageVolume.load();
            const imageIds = imageVolume.imageIds
                ? imageVolume.imageIds
                : dataSet.imageIds;
            let volumeInitialImageIdIndex = initialImageIdIndex;
            if (initialImageIdIndex !== undefined && imageIds !== dataSet.imageIds) {
                const requestedImageId = dataSet.imageIds[initialImageIdIndex];
                const remappedIndex = imageIds.indexOf(requestedImageId);
                if (remappedIndex >= 0) {
                    volumeInitialImageIdIndex = remappedIndex;
                }
                else {
                    console.warn(`[PlanarViewport] initialImageIdIndex remap failed: imageId ` +
                        `"${requestedImageId}" not found in the volume imageIds; ` +
                        `using the original index ${initialImageIdIndex}`);
                }
            }
            return {
                id: dataId,
                type: 'image',
                imageIds,
                initialImageIdIndex: volumeInitialImageIdIndex,
                acquisitionOrientation: options.acquisitionOrientation,
                imageData: dataSet.imageData,
                imageVolume,
                reference: dataSet.reference,
                renderMode: options.renderMode,
                useWorldCoordinateImageData: dataSet.useWorldCoordinateImageData,
                volumeId,
            };
        }
        const image = dataSet.image &&
            dataSet.image.imageId === dataSet.imageIds[clampedImageIdIndex]
            ? dataSet.image
            : await loadAndCacheImage(dataSet.imageIds[clampedImageIdIndex]);
        return {
            id: dataId,
            type: 'image',
            imageIds: dataSet.imageIds,
            image,
            imageData: dataSet.imageData,
            initialImageIdIndex,
            acquisitionOrientation: options.acquisitionOrientation,
            reference: dataSet.reference,
            renderMode: options.renderMode,
            useWorldCoordinateImageData: dataSet.useWorldCoordinateImageData,
            volumeId: options.volumeId,
        };
    }
    getDataSet(dataId) {
        const dataSet = getGenericViewportPlanarDisplaySet(dataId);
        if (!isPlanarRegisteredDataSet(dataSet)) {
            return;
        }
        return dataSet;
    }
}
function isPlanarRegisteredDataSet(value) {
    if (!value ||
        typeof value !== 'object' ||
        !Array.isArray(value.imageIds) ||
        value.imageIds.length === 0) {
        return false;
    }
    const dataSet = value;
    return ((dataSet.initialImageIdIndex === undefined ||
        typeof dataSet.initialImageIdIndex === 'number') &&
        (dataSet.volumeId === undefined || typeof dataSet.volumeId === 'string'));
}