@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,44 @@
+import type { ActorEntry, ICamera, IImage, IVolumeInput } from '../../../types';
+import type BlendModes from '../../../enums/BlendModes';
+import type { PlanarLegacyViewportProperties } from './planarLegacyCompatibility';
+import PlanarViewport from './PlanarViewport';
+import type { PlanarScaleInput } from './planarCameraScale';
+import type { PlanarViewPresentation, PlanarViewPresentationSelector, PlanarViewState } from './PlanarViewportTypes';
+declare class PlanarViewportLegacyAdapter extends PlanarViewport {
+    private readonly legacyCompatibility;
+    private cloneTuple;
+    getCamera(): PlanarViewState & ICamera<PlanarScaleInput>;
+    setCamera(cameraPatch: Partial<ICamera<PlanarScaleInput> & PlanarViewState>): void;
+    getViewPresentation(selector?: PlanarViewPresentationSelector): PlanarViewPresentation | undefined;
+    setViewPresentation(viewPres?: PlanarViewPresentation): void;
+    resetCamera(options?: Parameters<PlanarViewport['resetViewState']>[0]): boolean;
+    resetCameraForResize(): boolean;
+    get volumeIds(): Set<string>;
+    get csImage(): IImage | undefined;
+    getCornerstoneImage(): IImage | undefined;
+    getAllVolumeIds(): string[];
+    private applyLegacyPlanarPresentationPatch;
+    private applyLegacyParallelScalePatch;
+    private applyLegacyOrientationPatch;
+    private applyLegacyFocalPointPatch;
+    private isVolumeSliceRenderingActive;
+    private warnUnsupportedPositionOnlyCameraPatch;
+    removeData(dataId: string): void;
+    getActor(actorEntryUID: string): ActorEntry | undefined;
+    removeActors(actorEntryUIDs: string[]): void;
+    setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string>;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setProperties(properties?: PlanarLegacyViewportProperties, volumeIdOrSuppressEvents?: string | boolean, suppressEvents?: boolean): void;
+    getProperties(volumeId?: string): PlanarLegacyViewportProperties;
+    resetProperties(volumeId?: string): void;
+    setDefaultProperties(properties?: PlanarLegacyViewportProperties, imageId?: string): void;
+    clearDefaultProperties(imageId?: string): void;
+    resetToDefaultProperties(): void;
+    getBlendMode(filterActorUIDs?: string[]): BlendModes | undefined;
+    setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
+    getSlabThickness(): number;
+    getNumberOfSlices(): number;
+    protected onDestroy(): void;
+}
+export default PlanarViewportLegacyAdapter;

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

@@ -0,0 +1,279 @@
+import cache from '../../../cache/cache';
+import RENDERING_DEFAULTS from '../../../constants/rendering';
+import { ActorRenderMode } from '../../../types';
+import clonePoint3 from '../../../utilities/clonePoint3';
+import hasOwn from '../../../utilities/hasOwn';
+import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import { viewportProjection } from '../viewportProjection';
+import PlanarLegacyCompatibilityController from './PlanarLegacyCompatibilityController';
+import PlanarViewport from './PlanarViewport';
+import { cloneDisplayArea } from './planarViewState';
+class PlanarViewportLegacyAdapter extends PlanarViewport {
+    constructor() {
+        super(...arguments);
+        this.legacyCompatibility = new PlanarLegacyCompatibilityController(this.createLegacyCompatibilityHost());
+    }
+    cloneTuple(tuple) {
+        if (!tuple) {
+            return undefined;
+        }
+        return Array.from(tuple);
+    }
+    getCamera() {
+        const viewState = this.getViewState();
+        const camera = {
+            ...viewState,
+            ...this.getCameraForEvent(),
+        };
+        const orientation = viewState.orientation && typeof viewState.orientation === 'object'
+            ? {
+                ...viewState.orientation,
+                viewUp: this.cloneTuple(viewState.orientation.viewUp),
+                viewPlaneNormal: this.cloneTuple(viewState.orientation.viewPlaneNormal),
+            }
+            : viewState.orientation;
+        return {
+            ...camera,
+            focalPoint: this.cloneTuple(camera.focalPoint),
+            position: this.cloneTuple(camera.position),
+            viewUp: this.cloneTuple(camera.viewUp),
+            viewPlaneNormal: this.cloneTuple(camera.viewPlaneNormal),
+            orientation,
+        };
+    }
+    setCamera(cameraPatch) {
+        const viewStatePatch = {};
+        this.applyLegacyPlanarPresentationPatch(viewStatePatch, cameraPatch);
+        this.applyLegacyParallelScalePatch(viewStatePatch, cameraPatch);
+        this.applyLegacyOrientationPatch(viewStatePatch, cameraPatch);
+        this.applyLegacyFocalPointPatch(viewStatePatch, cameraPatch);
+        if (cameraPatch.position &&
+            !cameraPatch.focalPoint &&
+            !Object.keys(viewStatePatch).length) {
+            this.warnUnsupportedPositionOnlyCameraPatch();
+            return;
+        }
+        if (!Object.keys(viewStatePatch).length) {
+            return;
+        }
+        this.setViewState(viewStatePatch);
+    }
+    getViewPresentation(selector) {
+        return viewportProjection.getPresentation(this, {
+            selector,
+        });
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        if (hasOwn(viewPres, 'displayArea')) {
+            this.options = {
+                ...this.options,
+                displayArea: cloneDisplayArea(viewPres.displayArea),
+            };
+        }
+        const nextViewState = viewportProjection.withPresentation(this, viewPres);
+        if (nextViewState) {
+            this.setViewState(nextViewState);
+        }
+    }
+    resetCamera(options) {
+        return this.resetViewState(options);
+    }
+    resetCameraForResize() {
+        return this.resetViewStateForResize();
+    }
+    get volumeIds() {
+        const ids = new Set();
+        for (const actorEntry of this.getActors()) {
+            const candidates = [actorEntry.referencedId, actorEntry.uid];
+            for (const candidate of candidates) {
+                if (typeof candidate === 'string' && cache.getVolume(candidate)) {
+                    ids.add(candidate);
+                }
+            }
+        }
+        return ids;
+    }
+    get csImage() {
+        return this.getCornerstoneImage();
+    }
+    getCornerstoneImage() {
+        const planarData = this.getCurrentBinding()?.data;
+        return planarData?.image;
+    }
+    getAllVolumeIds() {
+        return Array.from(this.volumeIds);
+    }
+    applyLegacyPlanarPresentationPatch(viewStatePatch, cameraPatch) {
+        if (hasOwn(cameraPatch, 'orientation')) {
+            viewStatePatch.orientation = cameraPatch.orientation;
+        }
+        if (hasOwn(cameraPatch, 'anchorWorld')) {
+            viewStatePatch.anchorWorld = clonePoint3(cameraPatch.anchorWorld);
+        }
+        if (hasOwn(cameraPatch, 'anchorCanvas')) {
+            viewStatePatch.anchorCanvas = cameraPatch.anchorCanvas
+                ? [...cameraPatch.anchorCanvas]
+                : undefined;
+        }
+        if (hasOwn(cameraPatch, 'scale')) {
+            viewStatePatch.scale = cameraPatch.scale;
+        }
+        if (hasOwn(cameraPatch, 'scaleMode')) {
+            viewStatePatch.scaleMode = cameraPatch.scaleMode;
+        }
+        if (hasOwn(cameraPatch, 'rotation')) {
+            viewStatePatch.rotation = cameraPatch.rotation;
+        }
+        if (hasOwn(cameraPatch, 'flipHorizontal')) {
+            viewStatePatch.flipHorizontal = cameraPatch.flipHorizontal;
+        }
+        if (hasOwn(cameraPatch, 'flipVertical')) {
+            viewStatePatch.flipVertical = cameraPatch.flipVertical;
+        }
+        if (hasOwn(cameraPatch, 'displayArea')) {
+            viewStatePatch.displayArea = cameraPatch.displayArea;
+        }
+        if (hasOwn(cameraPatch, 'slice')) {
+            viewStatePatch.slice = cameraPatch.slice;
+        }
+    }
+    applyLegacyParallelScalePatch(viewStatePatch, cameraPatch) {
+        if (typeof cameraPatch.parallelScale !== 'number') {
+            return;
+        }
+        const resolvedICamera = this.getResolvedView()?.toICamera();
+        if (!resolvedICamera || typeof resolvedICamera.parallelScale !== 'number') {
+            return;
+        }
+        const currentScale = this.getScale();
+        const currentScaleY = Math.max(resolvedICamera.presentationScale?.[1] ?? currentScale[1] ?? 1, 1e-6);
+        const currentScaleX = Math.max(resolvedICamera.presentationScale?.[0] ??
+            currentScale[0] ??
+            currentScaleY, 1e-6);
+        const fitParallelScale = resolvedICamera.parallelScale * currentScaleY;
+        const nextScaleY = fitParallelScale / Math.max(cameraPatch.parallelScale, 1e-6);
+        const aspectScale = currentScaleX / currentScaleY;
+        viewStatePatch.displayArea = undefined;
+        viewStatePatch.scale = [nextScaleY * aspectScale, nextScaleY];
+        viewStatePatch.scaleMode = 'fit';
+    }
+    applyLegacyOrientationPatch(viewStatePatch, cameraPatch) {
+        if (!cameraPatch.viewPlaneNormal) {
+            return;
+        }
+        const currentICamera = this.getResolvedView()?.toICamera();
+        viewStatePatch.orientation = {
+            viewPlaneNormal: [...cameraPatch.viewPlaneNormal],
+            viewUp: cameraPatch.viewUp
+                ? [...cameraPatch.viewUp]
+                : currentICamera?.viewUp
+                    ? [...currentICamera.viewUp]
+                    : undefined,
+        };
+    }
+    applyLegacyFocalPointPatch(viewStatePatch, cameraPatch) {
+        if (!cameraPatch.focalPoint) {
+            return;
+        }
+        const focalPoint = [...cameraPatch.focalPoint];
+        viewStatePatch.anchorCanvas = [0.5, 0.5];
+        viewStatePatch.anchorWorld = focalPoint;
+        viewStatePatch.displayArea = undefined;
+        if (this.isVolumeSliceRenderingActive()) {
+            viewStatePatch.slice = {
+                kind: 'volumePoint',
+                sliceWorldPoint: focalPoint,
+            };
+        }
+    }
+    isVolumeSliceRenderingActive() {
+        const rendering = this.getCurrentPlanarRendering();
+        return (rendering?.renderMode === ActorRenderMode.CPU_VOLUME ||
+            rendering?.renderMode === ActorRenderMode.VTK_VOLUME_SLICE);
+    }
+    warnUnsupportedPositionOnlyCameraPatch() {
+        if (typeof process !== 'undefined' &&
+            process.env?.NODE_ENV === 'production') {
+            return;
+        }
+        console.warn('[PlanarViewportLegacyAdapter] Position-only planar camera patches are unsupported. Use focalPoint, parallelScale, or view state APIs.');
+    }
+    removeData(dataId) {
+        super.removeData(dataId);
+        this.legacyCompatibility.removeData(dataId);
+    }
+    getActor(actorEntryUID) {
+        return this.getActors().find((actorEntry) => actorEntry.uid === actorEntryUID);
+    }
+    removeActors(actorEntryUIDs) {
+        let didRemoveActor = false;
+        actorEntryUIDs
+            .filter((actorEntryUID) => typeof actorEntryUID === 'string')
+            .forEach((actorEntryUID) => {
+            const bindingDataId = this.findBindingDataIdByActorEntryUID(actorEntryUID);
+            if (bindingDataId) {
+                if (this.getDisplaySetRole(bindingDataId) === 'overlay') {
+                    genericViewportDataSetMetadataProvider.remove(bindingDataId);
+                }
+                this.removeData(bindingDataId);
+                didRemoveActor = true;
+            }
+        });
+        if (didRemoveActor) {
+            this.render();
+        }
+    }
+    async setStack(imageIds, currentImageIdIndex = 0) {
+        return this.legacyCompatibility.setStack(imageIds, currentImageIdIndex);
+    }
+    async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
+        return this.legacyCompatibility.setVolumes(volumeInputArray, immediate, suppressEvents);
+    }
+    async addVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
+        return this.legacyCompatibility.addVolumes(volumeInputArray, immediate, suppressEvents);
+    }
+    setProperties(properties = {}, volumeIdOrSuppressEvents, suppressEvents = false) {
+        this.legacyCompatibility.setProperties(properties, volumeIdOrSuppressEvents, suppressEvents);
+    }
+    getProperties(volumeId) {
+        return this.legacyCompatibility.getProperties(volumeId);
+    }
+    resetProperties(volumeId) {
+        this.legacyCompatibility.resetProperties(volumeId);
+    }
+    setDefaultProperties(properties = {}, imageId) {
+        this.legacyCompatibility.setDefaultProperties(properties, imageId);
+    }
+    clearDefaultProperties(imageId) {
+        this.legacyCompatibility.clearDefaultProperties(imageId);
+    }
+    resetToDefaultProperties() {
+        this.legacyCompatibility.resetToDefaultProperties();
+    }
+    getBlendMode(filterActorUIDs) {
+        return this.legacyCompatibility.getBlendMode(filterActorUIDs);
+    }
+    setBlendMode(blendMode, filterActorUIDs, immediate = false) {
+        this.legacyCompatibility.setBlendMode(blendMode, filterActorUIDs, immediate);
+    }
+    getSlabThickness() {
+        let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+        for (const actor of this.getActors()) {
+            if (actor.slabThickness > slabThickness) {
+                slabThickness = actor.slabThickness;
+            }
+        }
+        return slabThickness;
+    }
+    getNumberOfSlices() {
+        return this.legacyCompatibility.getNumberOfSlices();
+    }
+    onDestroy() {
+        this.legacyCompatibility.destroy();
+        super.onDestroy();
+    }
+}
+export default PlanarViewportLegacyAdapter;

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

@@ -0,0 +1,151 @@
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { BlendModes, InterpolationType, OrientationAxis } from '../../../enums';
+import type { ActorEntry, ActorRenderMode, ColormapPublic, IImage, IImageVolume, OrientationVectors, Point2, Point3, VOIRange } from '../../../types';
+import type { ViewportInput } from '../../../types/IViewport';
+import type ViewportInputOptions from '../../../types/ViewportInputOptions';
+import type { ViewPresentation, ViewPresentationSelector } from '../../../types';
+import type { BaseViewportRenderContext, BasePresentationProps, BindingRole, DataProvider, LoadedData, RenderPathResolver, ViewportDataReference } from '../ViewportArchitectureTypes';
+import type ICamera from '../../../types/ICamera';
+import type { CameraScaleMode, ViewAnchor } from '../ViewportCameraTypes';
+import type DisplayArea from '../../../types/displayArea';
+import type { PlanarScaleInput } from './planarCameraScale';
+export type PlanarRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE;
+export type PlanarEffectiveRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE | ActorRenderMode.CPU_VOLUME;
+export type PlanarOrientation = OrientationAxis.ACQUISITION | OrientationAxis.AXIAL | OrientationAxis.CORONAL | OrientationAxis.SAGITTAL | OrientationVectors;
+export interface PlanarRegisteredDataSet {
+    imageIds: string[];
+    initialImageIdIndex?: number;
+    volumeId?: string;
+    image?: IImage;
+    imageData?: vtkImageData;
+    useWorldCoordinateImageData?: boolean;
+    reference?: ViewportDataReference;
+}
+export interface PlanarSetDataOptions {
+    orientation?: PlanarOrientation;
+    cpuThresholds?: {
+        image?: number;
+        volume?: number;
+    };
+    role?: BindingRole;
+}
+export interface PlanarDataLoadOptions {
+    acquisitionOrientation?: PlanarViewState['orientation'];
+    orientation: PlanarOrientation;
+    renderMode: PlanarEffectiveRenderMode;
+    volumeId: string;
+}
+export interface PlanarPayload {
+    imageIds: string[];
+    initialImageIdIndex: number;
+    volumeId: string;
+    renderMode: PlanarEffectiveRenderMode;
+    acquisitionOrientation?: PlanarViewState['orientation'];
+    imageVolume?: IImageVolume;
+    image?: IImage;
+    imageData?: vtkImageData;
+    useWorldCoordinateImageData?: boolean;
+    reference?: ViewportDataReference;
+}
+export interface PlanarPresentationProps extends BasePresentationProps {
+    colormap?: ColormapPublic;
+    voiRange?: VOIRange;
+    invert?: boolean;
+}
+export type PlanarDisplayArea = Omit<DisplayArea, 'scale'> & {
+    scale?: PlanarScaleInput;
+    scaleMode?: CameraScaleMode;
+};
+export type PlanarViewportInputOptions = Omit<ViewportInputOptions, 'displayArea' | 'renderMode'> & {
+    displayArea?: PlanarDisplayArea;
+};
+export interface PlanarViewPresentation extends Omit<ViewPresentation, 'displayArea'> {
+    displayArea?: PlanarDisplayArea;
+    scale?: Point2;
+}
+export interface PlanarViewPresentationSelector extends ViewPresentationSelector {
+    scale?: boolean;
+}
+export type PlanarSliceState = {
+    kind: 'stackIndex';
+    imageIdIndex: number;
+} | {
+    kind: 'volumePoint';
+    sliceWorldPoint: Point3;
+};
+export interface PlanarViewState {
+    orientation?: PlanarOrientation;
+    slice?: PlanarSliceState;
+    anchorWorld?: Point3;
+    anchorCanvas?: ViewAnchor;
+    scale?: PlanarScaleInput;
+    scaleMode?: CameraScaleMode;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    displayArea?: PlanarDisplayArea;
+}
+export interface PlanarResolvedICamera extends ICamera<PlanarScaleInput> {
+    presentationScale?: Point2;
+    scaleMode?: CameraScaleMode;
+}
+export interface PlanarProperties {
+    blendMode?: BlendModes;
+    interpolationType?: InterpolationType;
+    slabThickness?: number;
+}
+export type PlanarDataPresentation = PlanarPresentationProps & PlanarProperties;
+export interface PlanarRenderPathRuntime {
+    renderMode: PlanarEffectiveRenderMode;
+}
+export interface PlanarActiveViewRuntime {
+    activeSourceICamera?: PlanarResolvedICamera;
+}
+export interface PlanarDataProvider extends DataProvider {
+    load(dataId: string, options?: PlanarDataLoadOptions): Promise<LoadedData<PlanarPayload>>;
+}
+export interface PlanarViewportInput extends Omit<ViewportInput, 'defaultOptions'> {
+    defaultOptions: PlanarViewportInputOptions;
+    dataProvider?: DataProvider;
+    renderPathResolver?: RenderPathResolver;
+}
+export interface PlanarViewportRenderContext extends BaseViewportRenderContext {
+    renderingEngineId: string;
+    type: 'planar';
+    viewport: {
+        element: HTMLDivElement;
+        getActiveDataId(): string | undefined;
+        invalidateResolvedView(): void;
+        getViewState(): PlanarViewState;
+        isCurrentDataId(dataId: string): boolean;
+        getOverlayActors(): ActorEntry[];
+    };
+    renderPath: PlanarRenderPathRuntime;
+    view: PlanarActiveViewRuntime;
+    display: {
+        requestRender(): void;
+        renderNow(): void;
+        setNeedsRender(): void;
+        markRendered(): void;
+        activateRenderMode(renderMode: PlanarEffectiveRenderMode): void;
+    };
+    cpu: {
+        canvas: HTMLCanvasElement;
+        composition: {
+            clearedRenderPassId: number;
+            renderPassId: number;
+        };
+        context: CanvasRenderingContext2D;
+    };
+    vtk: {
+        renderer: vtkRenderer;
+        canvas: HTMLCanvasElement;
+    };
+}
+type PlanarContextBase = Pick<PlanarViewportRenderContext, 'viewportId' | 'renderingEngineId' | 'type'>;
+export type PlanarCpuImageAdapterContext = PlanarContextBase & Pick<PlanarViewportRenderContext, 'viewport' | 'renderPath' | 'view' | 'display' | 'cpu'>;
+export type PlanarCpuVolumeAdapterContext = PlanarContextBase & Pick<PlanarViewportRenderContext, 'viewport' | 'renderPath' | 'view' | 'display' | 'cpu'>;
+export type PlanarVtkImageAdapterContext = PlanarContextBase & Pick<PlanarViewportRenderContext, 'viewport' | 'renderPath' | 'view' | 'display' | 'vtk'>;
+export type PlanarVtkVolumeAdapterContext = PlanarContextBase & Pick<PlanarViewportRenderContext, 'viewport' | 'renderPath' | 'view' | 'display' | 'vtk'>;
+export {};

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

@@ -0,0 +1,21 @@
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkImageAdapterContext } from './PlanarViewportTypes';
+export declare class VtkImageMapperRenderPath implements RenderPath<PlanarVtkImageAdapterContext> {
+    addData(ctx: PlanarVtkImageAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<PlanarDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private canvasToWorld;
+    private worldToCanvas;
+    private getFrameOfReferenceUID;
+    private getImageData;
+    private removeData;
+    private resize;
+}
+export declare class VtkImageMapperPath implements RenderPathDefinition<PlanarViewportRenderContext, PlanarVtkImageAdapterContext> {
+    readonly id = "planar:vtk-image-mapper";
+    readonly type = ViewportType.PLANAR_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): VtkImageMapperRenderPath;
+    selectContext(rootContext: PlanarViewportRenderContext): PlanarVtkImageAdapterContext;
+}