@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/VtkGeometry3DRenderPath.js

@@ -0,0 +1,156 @@
+import '@kitware/vtk.js/Rendering/Profiles/Geometry';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import { GeometryType, ViewportType } from '../../../enums';
+import uuidv4 from '../../../utilities/uuidv4';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
+import applyVolume3DCamera from './applyVolume3DCamera';
+export class VtkGeometry3DRenderPath {
+    async addData(ctx, data, options) {
+        const payload = data;
+        const actors = createActorEntries(payload.geometry);
+        const hadVisibleProps = hasVisibleProps(ctx);
+        actors.forEach((actorEntry) => {
+            ctx.vtk.renderer.addActor(actorEntry.actor);
+        });
+        if (!hadVisibleProps) {
+            ctx.vtk.renderer.resetCamera();
+        }
+        ctx.vtk.renderer.resetCameraClippingRange();
+        const rendering = {
+            renderMode: 'vtkGeometry3d',
+            actors,
+            frameOfReferenceUID: payload.geometry.type === GeometryType.SURFACE
+                ? payload.geometry.data.frameOfReferenceUID
+                : undefined,
+        };
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(ctx, camera);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(rendering);
+            },
+            render: () => {
+                this.render(ctx);
+            },
+            resize: () => {
+                this.resize(ctx);
+            },
+            removeData: () => {
+                this.removeData(ctx, rendering);
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        applyDataPresentation(rendering, props);
+    }
+    applyViewState(ctx, camera) {
+        applyVolume3DCamera(ctx, camera, {
+            resetClippingRange: true,
+        });
+    }
+    canvasToWorld(ctx, canvasPos) {
+        return canvasToWorldContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            canvasPos,
+        });
+    }
+    worldToCanvas(ctx, worldPos) {
+        return worldToCanvasContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            worldPos,
+        });
+    }
+    getFrameOfReferenceUID(rendering) {
+        return rendering.frameOfReferenceUID;
+    }
+    render(ctx) {
+        ctx.display.requestRender();
+    }
+    resize(ctx) {
+        ctx.display.requestRender();
+    }
+    removeData(ctx, rendering) {
+        rendering.actors.forEach((actorEntry) => {
+            ctx.vtk.renderer.removeActor(actorEntry.actor);
+        });
+    }
+}
+export class VtkGeometry3DPath {
+    constructor() {
+        this.id = 'volume3d:vtk-geometry';
+        this.type = ViewportType.VOLUME_3D_NEXT;
+    }
+    matches(data, options) {
+        return data.type === 'geometry' && options.renderMode === 'vtkGeometry3d';
+    }
+    createRenderPath() {
+        return new VtkGeometry3DRenderPath();
+    }
+    selectContext(rootContext) {
+        return rootContext;
+    }
+}
+function createActorEntries(geometry) {
+    if (geometry.type === GeometryType.SURFACE) {
+        const surface = geometry.data;
+        const polyData = vtkPolyData.newInstance();
+        polyData.getPoints().setData(surface.points, 3);
+        polyData.setPolys(vtkCellArray.newInstance({
+            values: Uint32Array.from(surface.polys),
+        }));
+        const mapper = vtkMapper.newInstance();
+        mapper.setInputData(polyData);
+        const actor = vtkActor.newInstance();
+        actor.setMapper(mapper);
+        actor.setVisibility(surface.visible !== false);
+        actor
+            .getProperty()
+            .setColor(surface.color[0] / 255, surface.color[1] / 255, surface.color[2] / 255);
+        return [
+            {
+                actor,
+                referencedId: geometry.id,
+                uid: uuidv4(),
+            },
+        ];
+    }
+    if (geometry.type === GeometryType.MESH) {
+        const mesh = geometry.data;
+        return mesh.actors.map((sourceActor, index) => {
+            return {
+                actor: sourceActor,
+                referencedId: geometry.id,
+                uid: uuidv4(),
+            };
+        });
+    }
+    throw new Error(`[VolumeViewport3D] Geometry type ${geometry.type} is not supported in 3D Next rendering`);
+}
+function applyDataPresentation(rendering, props) {
+    rendering.actors.forEach((actorEntry) => {
+        const actor = actorEntry.actor;
+        actor.setVisibility(props?.visible === false ? false : true);
+        if (props?.opacity !== undefined) {
+            actor.getProperty().setOpacity(props.opacity);
+        }
+        if (props?.color) {
+            actor
+                .getProperty()
+                .setColor(props.color[0] / 255, props.color[1] / 255, props.color[2] / 255);
+        }
+    });
+}
+function hasVisibleProps(ctx) {
+    const renderer = ctx.vtk.renderer;
+    return Boolean(renderer.getActors?.().length || renderer.getVolumes?.().length);
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/VtkVolume3DRenderPath.d.ts

@@ -0,0 +1,23 @@
+import '@kitware/vtk.js/Rendering/Profiles/Volume';
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { Volume3DDataPresentation, Volume3DViewportRenderContext, Volume3DVtkVolumeAdapterContext } from './viewport3DTypes';
+export declare class VtkVolume3DRenderPath implements RenderPath<Volume3DVtkVolumeAdapterContext> {
+    addData(ctx: Volume3DVtkVolumeAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<Volume3DDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private canvasToWorld;
+    private worldToCanvas;
+    private getFrameOfReferenceUID;
+    private getImageData;
+    private render;
+    private resize;
+    private removeData;
+}
+export declare class VtkVolume3DPath implements RenderPathDefinition<Volume3DViewportRenderContext, Volume3DVtkVolumeAdapterContext> {
+    readonly id = "volume3d:vtk-volume";
+    readonly type = ViewportType.VOLUME_3D_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): VtkVolume3DRenderPath;
+    selectContext(rootContext: Volume3DViewportRenderContext): Volume3DVtkVolumeAdapterContext;
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/VtkVolume3DRenderPath.js

@@ -0,0 +1,205 @@
+import '@kitware/vtk.js/Rendering/Profiles/Volume';
+import { Events, ViewportType } from '../../../enums';
+import eventTarget from '../../../eventTarget';
+import createLinearRGBTransferFunction from '../../../utilities/createLinearRGBTransferFunction';
+import invertRgbTransferFunction from '../../../utilities/invertRgbTransferFunction';
+import { updateOpacity as updateVolumeOpacity } from '../../../utilities/colormap';
+import uuidv4 from '../../../utilities/uuidv4';
+import createVolumeActor from '../../helpers/createVolumeActor';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
+import applyVolume3DCamera from './applyVolume3DCamera';
+import { getInitialVolume3DCamera } from './vtkVolume3DInitialCamera';
+import setVtkCameraClippingRange from '../setVtkCameraClippingRange';
+export class VtkVolume3DRenderPath {
+    async addData(ctx, data, options) {
+        const payload = data;
+        const hadVolume = ctx.vtk.renderer.getVolumes().length > 0;
+        const actor = await createVolumeActor({
+            volumeId: payload.volumeId,
+        }, ctx.viewport.element, ctx.viewportId, true);
+        const mapper = actor.getMapper();
+        ctx.vtk.renderer.addVolume(actor);
+        if (!hadVolume) {
+            const initialCamera = getInitialVolume3DCamera(ctx, payload.imageVolume);
+            if (initialCamera) {
+                applyCamera(ctx, initialCamera);
+            }
+        }
+        setCameraClippingRange(ctx);
+        const defaultRange = actor
+            .getProperty()
+            .getRGBTransferFunction(0)
+            .getRange();
+        const rendering = {
+            renderMode: 'vtkVolume3d',
+            actorEntryUID: uuidv4(),
+            actor,
+            defaultVOIRange: defaultRange
+                ? { lower: defaultRange[0], upper: defaultRange[1] }
+                : undefined,
+            imageVolume: payload.imageVolume,
+            mapper,
+            removeStreamingSubscriptions: subscribeToVolumeEvents(payload.volumeId, () => {
+                ctx.display.requestRender();
+            }),
+        };
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(ctx, camera);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(rendering);
+            },
+            getImageData: () => {
+                return this.getImageData(rendering);
+            },
+            render: () => {
+                this.render(ctx);
+            },
+            resize: () => {
+                this.resize(ctx);
+            },
+            removeData: () => {
+                this.removeData(ctx, rendering);
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        applyDataPresentation(rendering, props);
+    }
+    applyViewState(ctx, camera) {
+        applyCamera(ctx, camera);
+    }
+    canvasToWorld(ctx, canvasPos) {
+        return canvasToWorldContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            canvasPos,
+        });
+    }
+    worldToCanvas(ctx, worldPos) {
+        return worldToCanvasContextPool({
+            canvas: ctx.vtk.canvas,
+            renderer: ctx.vtk.renderer,
+            worldPos,
+        });
+    }
+    getFrameOfReferenceUID(rendering) {
+        return rendering.imageVolume.metadata?.FrameOfReferenceUID;
+    }
+    getImageData(rendering) {
+        return buildVolumeImageData(rendering.imageVolume);
+    }
+    render(ctx) {
+        ctx.display.requestRender();
+    }
+    resize(ctx) {
+        ctx.display.requestRender();
+    }
+    removeData(ctx, rendering) {
+        const { actor, removeStreamingSubscriptions } = rendering;
+        removeStreamingSubscriptions?.();
+        ctx.vtk.renderer.removeVolume(actor);
+    }
+}
+export class VtkVolume3DPath {
+    constructor() {
+        this.id = 'volume3d:vtk-volume';
+        this.type = ViewportType.VOLUME_3D_NEXT;
+    }
+    matches(data, options) {
+        return data.type === 'image' && options.renderMode === 'vtkVolume3d';
+    }
+    createRenderPath() {
+        return new VtkVolume3DRenderPath();
+    }
+    selectContext(rootContext) {
+        return rootContext;
+    }
+}
+function subscribeToVolumeEvents(volumeId, onProgress) {
+    const handleProgress = (evt) => {
+        const detail = evt.detail;
+        if (detail?.volumeId !== volumeId) {
+            return;
+        }
+        onProgress();
+    };
+    eventTarget.addEventListener(Events.IMAGE_VOLUME_MODIFIED, handleProgress);
+    eventTarget.addEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, handleProgress);
+    return () => {
+        eventTarget.removeEventListener(Events.IMAGE_VOLUME_MODIFIED, handleProgress);
+        eventTarget.removeEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, handleProgress);
+    };
+}
+function applyDataPresentation(rendering, props) {
+    const { actor, defaultVOIRange } = rendering;
+    const property = actor.getProperty();
+    const voiRange = props?.voiRange ?? defaultVOIRange;
+    actor.setVisibility(props?.visible === false ? false : true);
+    if (props?.opacity !== undefined) {
+        updateVolumeOpacity(actor, props.opacity);
+    }
+    if (!voiRange) {
+        return;
+    }
+    const transferFunction = createLinearRGBTransferFunction(voiRange);
+    if (props?.invert) {
+        invertRgbTransferFunction(transferFunction);
+    }
+    property.setRGBTransferFunction(0, transferFunction);
+    if (props?.interpolationType !== undefined) {
+        property.setInterpolationType(props.interpolationType);
+    }
+    if (props?.sampleDistanceMultiplier !== undefined) {
+        applySampleDistanceMultiplier(rendering.mapper, props.sampleDistanceMultiplier);
+    }
+}
+function applyCamera(ctx, camera) {
+    applyVolume3DCamera(ctx, camera);
+    if (camera && camera.clippingRange === undefined) {
+        setCameraClippingRange(ctx);
+    }
+}
+function applySampleDistanceMultiplier(mapper, multiplier) {
+    const imageData = mapper.getInputData?.();
+    if (!imageData) {
+        return;
+    }
+    const spacing = imageData.getSpacing();
+    const defaultSampleDistance = (spacing[0] + spacing[1] + spacing[2]) / 6;
+    const safeMultiplier = Number.isFinite(multiplier)
+        ? Math.max(multiplier, 0.001)
+        : 1;
+    mapper.setSampleDistance(defaultSampleDistance * safeMultiplier);
+}
+function setCameraClippingRange(ctx) {
+    setVtkCameraClippingRange(ctx.vtk.renderer.getActiveCamera());
+}
+function buildVolumeImageData(imageVolume) {
+    const vtkImageData = imageVolume.imageData;
+    if (!vtkImageData) {
+        return;
+    }
+    return {
+        dimensions: vtkImageData.getDimensions(),
+        spacing: vtkImageData.getSpacing(),
+        origin: vtkImageData.getOrigin(),
+        direction: vtkImageData.getDirection(),
+        imageData: vtkImageData,
+        metadata: {
+            Modality: imageVolume.metadata?.Modality,
+            FrameOfReferenceUID: imageVolume.metadata?.FrameOfReferenceUID,
+        },
+        get scalarData() {
+            return imageVolume.voxelManager?.getScalarData();
+        },
+        scaling: imageVolume.scaling,
+        hasPixelSpacing: imageVolume.hasPixelSpacing,
+        voxelManager: imageVolume.voxelManager,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/applyVolume3DCamera.d.ts

@@ -0,0 +1,4 @@
+import type { Volume3DCamera, Volume3DViewportRenderContext } from './viewport3DTypes';
+export default function applyVolume3DCamera(ctx: Pick<Volume3DViewportRenderContext, 'vtk'>, camera?: Partial<Volume3DCamera>, options?: {
+    resetClippingRange?: boolean;
+}): void;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/applyVolume3DCamera.js

@@ -0,0 +1,33 @@
+export default function applyVolume3DCamera(ctx, camera, options = {}) {
+    if (!camera) {
+        return;
+    }
+    const vtkCamera = ctx.vtk.renderer.getActiveCamera();
+    if (camera.parallelProjection !== undefined) {
+        vtkCamera.setParallelProjection(camera.parallelProjection);
+    }
+    if (camera.viewUp) {
+        vtkCamera.setViewUp(...camera.viewUp);
+    }
+    if (camera.viewPlaneNormal) {
+        vtkCamera.setDirectionOfProjection(-camera.viewPlaneNormal[0], -camera.viewPlaneNormal[1], -camera.viewPlaneNormal[2]);
+    }
+    if (camera.position) {
+        vtkCamera.setPosition(...camera.position);
+    }
+    if (camera.focalPoint) {
+        vtkCamera.setFocalPoint(...camera.focalPoint);
+    }
+    if (camera.parallelScale !== undefined) {
+        vtkCamera.setParallelScale(camera.parallelScale);
+    }
+    if (camera.viewAngle !== undefined) {
+        vtkCamera.setViewAngle(camera.viewAngle);
+    }
+    if (camera.clippingRange !== undefined) {
+        vtkCamera.setClippingRange(...camera.clippingRange);
+    }
+    else if (options.resetClippingRange) {
+        ctx.vtk.renderer.resetCameraClippingRange();
+    }
+}

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/index.d.ts

@@ -0,0 +1,10 @@
+import { getVolume3DProjectionSnapshot } from './volume3DProjectionAdapter';
+export { DefaultVolume3DDataProvider } from './DefaultVolume3DDataProvider';
+export { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, } from './Volume3DRenderPathResolver';
+export declare const volume3DProjection: {
+    adapter: import("..").ViewportProjectionAdapter<import("./viewport3DTypes").Volume3DCamera, import("./Volume3DProjectionTypes").Volume3DProjectionPresentation, import("./Volume3DProjectionTypes").Volume3DProjectionSnapshot>;
+    getSnapshot: typeof getVolume3DProjectionSnapshot;
+};
+export type { Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, } from './volume3DProjectionAdapter';
+export { default } from './viewport3D';
+export type { Volume3DCamera, Volume3DDataPresentation, Volume3DPresentationProps, Volume3DProperties, Volume3DRequestedRenderMode, Volume3DSetDataOptions, VolumeViewport3DInput, } from './viewport3DTypes';

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/index.js

@@ -0,0 +1,8 @@
+import { getVolume3DProjectionSnapshot, volume3DProjectionAdapter, } from './volume3DProjectionAdapter';
+export { DefaultVolume3DDataProvider } from './DefaultVolume3DDataProvider';
+export { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, } from './Volume3DRenderPathResolver';
+export const volume3DProjection = {
+    adapter: volume3DProjectionAdapter,
+    getSnapshot: getVolume3DProjectionSnapshot,
+};
+export { default } from './viewport3D';

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.d.ts

@@ -0,0 +1,60 @@
+import { ViewportType } from '../../../enums';
+import type { ActorEntry, ICamera, IImageData, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type ViewportInputOptions from '../../../types/ViewportInputOptions';
+import type { DataAddOptions, ViewportDataBinding } from '../ViewportArchitectureTypes';
+import GenericViewport from '../GenericViewport';
+import { type GenericViewportReferenceContext } from '../genericViewportReferenceCompatibility';
+import Volume3DResolvedView from './Volume3DResolvedView';
+import type { Volume3DCamera, Volume3DDataPresentation, Volume3DSetDataOptions, Volume3DViewportRenderContext, VolumeViewport3DInput } from './viewport3DTypes';
+declare class VolumeViewport3D extends GenericViewport<Volume3DCamera, Volume3DDataPresentation, Volume3DViewportRenderContext> {
+    readonly type = ViewportType.VOLUME_3D_NEXT;
+    readonly renderingEngineId: string;
+    readonly canvas: HTMLCanvasElement;
+    sWidth: number;
+    sHeight: number;
+    defaultOptions: ViewportInputOptions;
+    suppressEvents: boolean;
+    protected renderContext: Volume3DViewportRenderContext;
+    private primaryDataId?;
+    static get useCustomRenderingPipeline(): boolean;
+    getUseCustomRenderingPipeline(): boolean;
+    setRendered(): void;
+    constructor(args: VolumeViewport3DInput);
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: Volume3DSetDataOptions;
+    }>): Promise<void>;
+    addDisplaySet(displaySetId: string, options?: Volume3DSetDataOptions | DataAddOptions): Promise<void>;
+    getRenderingEngine(): import("../..").RenderingEngine;
+    getImageIds(): string[];
+    getRenderer(): import("@kitware/vtk.js/Rendering/Core/Renderer").vtkRenderer;
+    getCanvas(): HTMLCanvasElement;
+    getVtkActiveCamera(): import("@kitware/vtk.js/Rendering/Core/Camera").vtkCamera;
+    getViewState(): Volume3DCamera & ICamera;
+    setViewState(viewStatePatch: Partial<Volume3DCamera>): void;
+    protected getRuntimeCamera(): Volume3DCamera & ICamera;
+    getResolvedView(): Volume3DResolvedView;
+    getViewReference(_viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    getVolumeId(): string | undefined;
+    hasVolumeId(volumeId: string): boolean;
+    hasVolumeURI(volumeURI: string): boolean;
+    getImageData(): IImageData | undefined;
+    getActors(): ActorEntry[];
+    getDefaultActor(): ActorEntry | undefined;
+    resetViewState(): boolean;
+    resetViewStateForResize(): boolean;
+    resize(): void;
+    render(): void;
+    protected onDestroy(): void;
+    private getProjectionSnapshot;
+    protected getCurrentBinding(): ViewportDataBinding<Volume3DDataPresentation>;
+    protected getReferenceViewContexts(): GenericViewportReferenceContext[];
+    private requestRenderingEngineRender;
+    private resolveRenderMode;
+    private getDataSet;
+    private getVolume3DPayload;
+    private resolveFrameOfReferenceUID;
+    private getVolume3DRendering;
+    private getActorEntriesForRendering;
+}
+export default VolumeViewport3D;