@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,111 @@
+class PlanarMountedData {
+    constructor(host) {
+        this.host = host;
+    }
+    resolveBindingRole(options) {
+        return options.role === 'source' ? 'source' : 'overlay';
+    }
+    getActiveDataId() {
+        return this.sourceDataId;
+    }
+    clearActiveDataId() {
+        this.sourceDataId = undefined;
+    }
+    getCurrentBinding() {
+        if (this.sourceDataId) {
+            return (this.host.getBinding(this.sourceDataId) ?? this.host.getFirstBinding());
+        }
+        return this.host.getFirstBinding();
+    }
+    getFirstBoundDataId() {
+        for (const [dataId] of this.host.getBindings()) {
+            return dataId;
+        }
+    }
+    hasBinding(dataId) {
+        return Boolean(this.host.getBinding(dataId));
+    }
+    promoteSourceDataId(dataId) {
+        for (const [bindingDataId, binding] of this.host.getBindings()) {
+            binding.role = bindingDataId === dataId ? 'source' : 'overlay';
+        }
+        this.sourceDataId = dataId;
+    }
+    handleRemovedData(dataId) {
+        if (this.sourceDataId !== dataId) {
+            return;
+        }
+        this.sourceDataId = undefined;
+        this.promoteFirstAvailableBindingToSource();
+    }
+    removeBindingsExcept(keepDataIds) {
+        const dataIds = Array.from(this.host.getBindings(), ([dataId]) => dataId);
+        for (const dataId of dataIds) {
+            if (!keepDataIds.has(dataId)) {
+                this.host.removeData(dataId);
+            }
+        }
+    }
+    getActorForDataId(dataId) {
+        const binding = this.host.getBinding(dataId);
+        return binding?.getActorEntry?.(binding.data);
+    }
+    getBindingActor(dataId) {
+        const rendering = this.host.getBinding(dataId)?.rendering;
+        return rendering?.actor ?? rendering?.compatibilityActor;
+    }
+    getActors() {
+        return [
+            ...this.getProjectedActorEntries('source'),
+            ...this.getProjectedActorEntries('overlay'),
+        ];
+    }
+    getDefaultActor() {
+        return (this.getProjectedActorEntries('source')[0] ??
+            this.getProjectedActorEntries()[0]);
+    }
+    getProjectedActorEntries(role) {
+        const actorEntries = [];
+        for (const [, binding] of this.host.getBindings()) {
+            if (role && binding.role !== role) {
+                continue;
+            }
+            const actorEntry = binding.getActorEntry?.(binding.data);
+            if (actorEntry) {
+                actorEntries.push(actorEntry);
+            }
+        }
+        return actorEntries;
+    }
+    findBindingDataIdByActorEntryUID(actorEntryUID) {
+        for (const [dataId, binding] of this.host.getBindings()) {
+            const actorEntry = binding.getActorEntry?.(binding.data);
+            if (actorEntry?.uid === actorEntryUID) {
+                return dataId;
+            }
+        }
+    }
+    findDataIdByVolumeId(volumeId) {
+        for (const [dataId, binding] of this.host.getBindings()) {
+            const bindingVolumeId = binding.data?.volumeId;
+            if (bindingVolumeId === volumeId) {
+                return dataId;
+            }
+        }
+    }
+    getDefaultVOIRange(dataId) {
+        const targetDataId = dataId ?? this.sourceDataId ?? this.getCurrentBinding()?.data.id;
+        const rendering = targetDataId
+            ? this.host.getBinding(targetDataId)?.rendering
+            : undefined;
+        const defaultVOIRange = rendering?.defaultVOIRange;
+        return defaultVOIRange ? { ...defaultVOIRange } : undefined;
+    }
+    promoteFirstAvailableBindingToSource() {
+        const firstBindingDataId = this.getFirstBoundDataId();
+        if (firstBindingDataId) {
+            this.promoteSourceDataId(firstBindingDataId);
+        }
+    }
+}
+export default PlanarMountedData;

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

@@ -0,0 +1,58 @@
+import { ViewportType } from '../../../enums';
+import type { Point2, Point3 } from '../../../types';
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot } from '../ViewportProjectionTypes';
+import type { PlanarDisplayArea, PlanarResolvedICamera, PlanarViewPresentation, PlanarViewState } from './PlanarViewportTypes';
+export declare const PLANAR_PROJECTION_ID = "planar";
+export type PlanarResolvedViewLike = {
+    state: {
+        viewState: PlanarViewState;
+        canvasWidth: number;
+        canvasHeight: number;
+    };
+    pan: Point2;
+    scale: Point2;
+    zoom: number;
+    rotation: number;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    toICamera(): PlanarResolvedICamera;
+    withPan(pan: Point2): {
+        state: {
+            viewState: PlanarViewState;
+        };
+    };
+};
+export type PlanarProjectionViewport = {
+    type: ViewportType | string;
+    element?: HTMLDivElement;
+    getDisplayArea?(): PlanarDisplayArea | undefined;
+    getFrameOfReferenceUID?(): string | undefined;
+    getResolvedView?(args?: {
+        frameOfReferenceUID?: string;
+        sliceIndex?: number;
+    }): PlanarResolvedViewLike | undefined;
+    getViewState?(): PlanarViewState;
+};
+export interface PlanarProjectionPresentation extends ProjectionPresentation<PlanarDisplayArea> {
+    rawPan: Point2;
+    scaleVector: Point2;
+}
+export interface PlanarProjectionSnapshot extends ProjectionSnapshot<PlanarViewState, PlanarProjectionPresentation> {
+    canvasHeight: number;
+    canvasWidth: number;
+    displayArea?: PlanarDisplayArea;
+    resolvedView?: PlanarResolvedViewLike;
+    resolveViewState?: (viewState: PlanarViewState) => PlanarResolvedViewLike | undefined;
+}
+export interface PlanarProjectionRequest extends ProjectionRequest<PlanarProjectionViewport> {
+    canvasHeight?: number;
+    canvasWidth?: number;
+    displayArea?: PlanarDisplayArea;
+    frameOfReferenceUID?: string;
+    resolvedView?: PlanarResolvedViewLike;
+    resolveViewState?: (viewState: PlanarViewState) => PlanarResolvedViewLike | undefined;
+    sliceIndex?: number;
+    viewState?: PlanarViewState;
+}
+export type PlanarProjectionAdapterPresentation = PlanarViewPresentation;

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

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

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

@@ -0,0 +1,28 @@
+import type { PlanarViewState, PlanarEffectiveRenderMode, PlanarOrientation, PlanarRegisteredDataSet } from './PlanarViewportTypes';
+export declare const DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD: number;
+export declare const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD: number;
+export interface SelectedPlanarRenderPath {
+    acquisitionOrientation?: PlanarViewState['orientation'];
+    renderMode: PlanarEffectiveRenderMode;
+    volumeId: string;
+}
+export interface PlanarRenderPathDecisionOptions {
+    orientation?: PlanarOrientation;
+    cpuThresholds?: {
+        image?: number;
+        volume?: number;
+    };
+    useSliceRendering?: boolean;
+    webGLAvailable?: boolean;
+}
+export declare class PlanarRenderPathDecisionService {
+    select(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;
+    private selectImageRenderMode;
+    private selectVolumeRenderMode;
+    private shouldUseCPUForImage;
+    private shouldUseCPUForVolume;
+}
+export declare const defaultPlanarRenderPathDecisionService: PlanarRenderPathDecisionService;
+export declare function selectPlanarRenderPath(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;
+export declare function getPlanarAcquisitionOrientation(imageIds: string[]): PlanarViewState['orientation'] | undefined;
+export declare function shouldUseCPU(imageIds: string[], threshold?: number): boolean;

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

@@ -0,0 +1,145 @@
+import { vec3 } from 'gl-matrix';
+import cache from '../../../cache/cache';
+import { OrientationAxis } from '../../../enums';
+import { getConfiguration, getShouldUseCPURendering } from '../../../init';
+import * as metaData from '../../../metaData';
+import { ActorRenderMode } from '../../../types';
+import { isValidVolume } from '../../../utilities/isValidVolume';
+import { getOrientationFromScanAxisNormal } from '../../helpers/getCameraVectors';
+export const DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD = 64 * 1024 * 1024;
+export const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD = 64 * 1024 * 1024;
+export class PlanarRenderPathDecisionService {
+    select(dataSet, options = {}) {
+        if (!dataSet.imageIds.length) {
+            throw new Error('[PlanarViewport] Cannot add an empty planar dataset');
+        }
+        const orientation = options.orientation || OrientationAxis.ACQUISITION;
+        const acquisitionOrientation = getPlanarAcquisitionOrientation(dataSet.imageIds);
+        const volumeId = getVolumeId(dataSet);
+        const isAcquisitionPath = orientation === OrientationAxis.ACQUISITION ||
+            (acquisitionOrientation !== undefined &&
+                orientation === acquisitionOrientation);
+        const useVolumePath = isVolumeBackedDataSet(dataSet, isAcquisitionPath);
+        if (!isAcquisitionPath &&
+            !useVolumePath &&
+            !dataSet.useWorldCoordinateImageData) {
+            throw new Error('[PlanarViewport] Non-acquisition rendering requires a valid volume dataset');
+        }
+        if (useVolumePath && !supportsVolumeRendering(dataSet)) {
+            throw new Error('[PlanarViewport] Volume rendering requires a valid volume dataset');
+        }
+        return {
+            acquisitionOrientation,
+            renderMode: useVolumePath
+                ? this.selectVolumeRenderMode(dataSet, options)
+                : this.selectImageRenderMode(dataSet, options),
+            volumeId,
+        };
+    }
+    selectImageRenderMode(dataSet, options) {
+        return this.shouldUseCPUForImage(dataSet, options)
+            ? ActorRenderMode.CPU_IMAGE
+            : ActorRenderMode.VTK_IMAGE;
+    }
+    selectVolumeRenderMode(dataSet, options) {
+        return this.shouldUseCPUForVolume(dataSet, options)
+            ? ActorRenderMode.CPU_VOLUME
+            : ActorRenderMode.VTK_VOLUME_SLICE;
+    }
+    shouldUseCPUForImage(dataSet, options) {
+        if (options.webGLAvailable === false) {
+            return true;
+        }
+        const configuredCpuThresholds = getConfiguredPlanarCpuThresholds();
+        return shouldUseCPU(dataSet.imageIds, options.cpuThresholds?.image ??
+            configuredCpuThresholds?.image ??
+            DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD);
+    }
+    shouldUseCPUForVolume(dataSet, options) {
+        if (options.webGLAvailable === false) {
+            return true;
+        }
+        const configuredCpuThresholds = getConfiguredPlanarCpuThresholds();
+        return shouldUseCPU(dataSet.imageIds, options.cpuThresholds?.volume ??
+            configuredCpuThresholds?.volume ??
+            DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD);
+    }
+}
+export const defaultPlanarRenderPathDecisionService = new PlanarRenderPathDecisionService();
+export function selectPlanarRenderPath(dataSet, options = {}) {
+    return defaultPlanarRenderPathDecisionService.select(dataSet, options);
+}
+export function getPlanarAcquisitionOrientation(imageIds) {
+    const imageId = imageIds[0];
+    if (!imageId) {
+        return;
+    }
+    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+    const imageOrientationPatient = imagePlaneModule?.imageOrientationPatient;
+    if (!imageOrientationPatient || imageOrientationPatient.length !== 6) {
+        return;
+    }
+    const rowVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+    const colVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowVec, colVec);
+    const orientation = getOrientationFromScanAxisNormal([
+        scanAxisNormal[0],
+        scanAxisNormal[1],
+        scanAxisNormal[2],
+    ]);
+    if (orientation !== OrientationAxis.AXIAL &&
+        orientation !== OrientationAxis.CORONAL &&
+        orientation !== OrientationAxis.SAGITTAL) {
+        return;
+    }
+    return orientation;
+}
+export function shouldUseCPU(imageIds, threshold = DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD) {
+    if (getShouldUseCPURendering()) {
+        return true;
+    }
+    const imageId = imageIds[0];
+    if (!imageId) {
+        return false;
+    }
+    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+    const rows = imagePlaneModule?.rows;
+    const columns = imagePlaneModule?.columns;
+    if (!isPositiveSafeInteger(rows) || !isPositiveSafeInteger(columns)) {
+        return false;
+    }
+    if (!Number.isFinite(threshold)) {
+        return false;
+    }
+    const normalizedThreshold = Math.trunc(threshold);
+    if (!Number.isSafeInteger(normalizedThreshold) || normalizedThreshold < 0) {
+        return false;
+    }
+    return (BigInt(rows) * BigInt(columns) * BigInt(imageIds.length) >=
+        BigInt(normalizedThreshold));
+}
+function getVolumeId(dataSet) {
+    return dataSet.volumeId || cache.generateVolumeId(dataSet.imageIds);
+}
+function hasExplicitCachedVolume(dataSet) {
+    return !!(dataSet.volumeId && cache.getVolume(dataSet.volumeId));
+}
+function supportsVolumeRendering(dataSet) {
+    return hasExplicitCachedVolume(dataSet) || isValidVolume(dataSet.imageIds);
+}
+function isVolumeBackedDataSet(dataSet, isAcquisitionPath) {
+    if (dataSet.useWorldCoordinateImageData) {
+        return false;
+    }
+    if (dataSet.volumeId) {
+        return true;
+    }
+    return !isAcquisitionPath && supportsVolumeRendering(dataSet);
+}
+function isPositiveSafeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+function getConfiguredPlanarCpuThresholds() {
+    return getConfiguration().rendering?.planar?.cpuThresholds;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import { CpuImageSlicePath } from './CpuImageSliceRenderPath';
+import { CpuVolumeSlicePath } from './CpuVolumeSliceRenderPath';
+import { VtkImageMapperPath } from './VtkImageMapperRenderPath';
+import { VtkVolumeSlicePath } from './VtkVolumeSliceRenderPath';
+export function createDefaultPlanarRenderPaths() {
+    return [
+        new CpuImageSlicePath(),
+        new CpuVolumeSlicePath(),
+        new VtkImageMapperPath(),
+        new VtkVolumeSlicePath(),
+    ];
+}
+export function createPlanarRenderPathResolver(paths = createDefaultPlanarRenderPaths()) {
+    return new DefaultRenderPathResolver(paths);
+}

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

@@ -0,0 +1,91 @@
+import type { IImage, IImageVolume, Point2, Point3 } from '../../../types';
+import ResolvedViewportView from '../ResolvedViewportView';
+import { type PlanarSliceBasis } from './planarSliceBasis';
+import { type PlanarScaleInput } from './planarCameraScale';
+import type { PlanarViewState, PlanarPayload, PlanarResolvedICamera, PlanarViewportRenderContext } from './PlanarViewportTypes';
+import type { PlanarRendering } from './planarRuntimeTypes';
+type PlanarViewResolutionRenderContext = Partial<Pick<PlanarViewportRenderContext, 'cpu' | 'vtk'>>;
+type BasePlanarResolvedViewState = {
+    viewState: PlanarViewState;
+    canvasWidth: number;
+    canvasHeight: number;
+    frameOfReferenceUID?: string;
+};
+type PlanarStackResolvedViewState = BasePlanarResolvedViewState & {
+    currentImageIdIndex: number;
+    image: IImage;
+    maxImageIdIndex: number;
+    usePixelGridCenter: boolean;
+};
+type PlanarVolumeResolvedViewState = BasePlanarResolvedViewState & {
+    currentImageIdIndex: number;
+    imageVolume: IImageVolume;
+    maxImageIdIndex: number;
+    usePixelGridCenter: boolean;
+};
+export declare function resolvePlanarStackImageIdIndex(args: {
+    fallbackImageIdIndex: number;
+    viewState?: PlanarViewState;
+}): number;
+declare abstract class BasePlanarResolvedView<TState extends BasePlanarResolvedViewState> extends ResolvedViewportView<TState, PlanarResolvedICamera> {
+    protected cachedSliceBasis?: PlanarSliceBasis;
+    private cachedPresentation?;
+    get pan(): Point2;
+    get zoom(): number;
+    get scale(): Point2;
+    get rotation(): number;
+    getSliceBasis(): PlanarSliceBasis;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    withZoom(zoom: number, canvasPoint?: Point2): BasePlanarResolvedView<TState>;
+    withScale(scale: PlanarScaleInput, canvasPoint?: Point2): BasePlanarResolvedView<TState>;
+    withPan(pan: Point2): BasePlanarResolvedView<TState>;
+    flipHorizontal(): BasePlanarResolvedView<TState>;
+    flipVertical(): BasePlanarResolvedView<TState>;
+    indexToWorld(_index: Point3): Point3 | undefined;
+    protected buildICamera(): PlanarResolvedICamera;
+    protected getPresentation(): import("./planarRenderCamera").DerivedPlanarPresentation;
+    protected requireResolvedICamera(): Required<Pick<PlanarResolvedICamera, 'focalPoint' | 'parallelScale' | 'viewPlaneNormal' | 'viewUp'>> & Pick<PlanarResolvedICamera, 'presentationScale'>;
+    protected createViewStateState(viewState: PlanarViewState): TState;
+    protected abstract buildSliceBasis(): PlanarSliceBasis;
+    protected abstract cloneWithViewState(viewState: PlanarViewState): BasePlanarResolvedView<TState>;
+}
+declare class PlanarStackResolvedView extends BasePlanarResolvedView<PlanarStackResolvedViewState> {
+    constructor(state: Omit<PlanarStackResolvedViewState, 'viewState'> & {
+        viewState?: PlanarViewState;
+    });
+    protected buildSliceBasis(): PlanarSliceBasis;
+    protected cloneWithViewState(viewState: PlanarViewState): PlanarStackResolvedView;
+}
+declare class PlanarVolumeResolvedView extends BasePlanarResolvedView<PlanarVolumeResolvedViewState> {
+    constructor(state: Omit<PlanarVolumeResolvedViewState, 'viewState'> & {
+        viewState?: PlanarViewState;
+        sliceBasis?: PlanarSliceBasis;
+    });
+    indexToWorld(index: Point3): Point3 | undefined;
+    protected buildSliceBasis(): PlanarSliceBasis;
+    protected cloneWithViewState(viewState: PlanarViewState): PlanarVolumeResolvedView;
+}
+export declare function getPlanarViewStateCanvasDimensions(args: {
+    rendering: PlanarRendering;
+    renderContext: PlanarViewResolutionRenderContext;
+}): {
+    canvasHeight: number;
+    canvasWidth: number;
+};
+export declare function resolvePlanarViewportView(args: {
+    viewState: PlanarViewState;
+    data?: PlanarPayload;
+    frameOfReferenceUID?: string;
+    imageIds?: string[];
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewResolutionRenderContext;
+    canvasDimensions?: {
+        canvasHeight: number;
+        canvasWidth: number;
+    };
+    sliceIndex?: number;
+}): PlanarStackResolvedView | PlanarVolumeResolvedView | undefined;
+export type { BasePlanarResolvedViewState, PlanarStackResolvedViewState, PlanarViewResolutionRenderContext, PlanarVolumeResolvedViewState, };
+export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, };