@cornerstonejs/core 3.29.1 → 3.29.3

package/dist/esm/RenderingEngine/SequentialRenderingEngine.d.ts

@@ -0,0 +1,18 @@
+import BaseRenderingEngine from './BaseRenderingEngine';
+import type IStackViewport from '../types/IStackViewport';
+import type IVolumeViewport from '../types/IVolumeViewport';
+import type * as EventTypes from '../types/EventTypes';
+import type { InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
+declare class SequentialRenderingEngine extends BaseRenderingEngine {
+    protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
+    protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput): void;
+    protected setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
+    protected _resizeVTKViewports(vtkDrivenViewports: (IStackViewport | IVolumeViewport)[], keepCamera?: boolean, immediate?: boolean): void;
+    protected _renderFlaggedViewports: () => void;
+    protected renderViewportUsingCustomOrVtkPipeline(viewport: IViewport): EventTypes.ImageRenderedEventDetail;
+    protected _renderViewportFromVtkCanvasToOnscreenCanvas(viewport: IViewport, offScreenCanvas: HTMLCanvasElement): EventTypes.ImageRenderedEventDetail;
+    private _resizeOffScreenCanvasForSingleViewport;
+    private _resize;
+    private getWidgetRenderers;
+}
+export default SequentialRenderingEngine;

package/dist/esm/RenderingEngine/SequentialRenderingEngine.js

@@ -0,0 +1,235 @@
+import BaseRenderingEngine, { VIEWPORT_MIN_SIZE } from './BaseRenderingEngine';
+import Events from '../enums/Events';
+import eventTarget from '../eventTarget';
+import triggerEvent from '../utilities/triggerEvent';
+import ViewportType from '../enums/ViewportType';
+import VolumeViewport from './VolumeViewport';
+import StackViewport from './StackViewport';
+import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
+import getOrCreateCanvas from './helpers/getOrCreateCanvas';
+import VolumeViewport3D from './VolumeViewport3D';
+class SequentialRenderingEngine extends BaseRenderingEngine {
+    constructor() {
+        super(...arguments);
+        this._renderFlaggedViewports = () => {
+            this._throwIfDestroyed();
+            const viewports = this._getViewportsAsArray();
+            const eventDetailArray = [];
+            for (let i = 0; i < viewports.length; i++) {
+                const viewport = viewports[i];
+                if (this._needsRender.has(viewport.id)) {
+                    const eventDetail = this.renderViewportUsingCustomOrVtkPipeline(viewport);
+                    eventDetailArray.push(eventDetail);
+                    viewport.setRendered();
+                    this._needsRender.delete(viewport.id);
+                    if (this._needsRender.size === 0) {
+                        break;
+                    }
+                }
+            }
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+            eventDetailArray.forEach((eventDetail) => {
+                if (!eventDetail?.element) {
+                    return;
+                }
+                triggerEvent(eventDetail.element, Events.IMAGE_RENDERED, eventDetail);
+            });
+        };
+    }
+    enableVTKjsDrivenViewport(viewportInputEntry) {
+        const viewports = this._getViewportsAsArray();
+        const viewportsDrivenByVtkJs = viewports.filter((vp) => viewportTypeUsesCustomRenderingPipeline(vp.type) === false);
+        const canvasesDrivenByVtkJs = viewportsDrivenByVtkJs.map((vp) => vp.canvas);
+        const canvas = getOrCreateCanvas(viewportInputEntry.element);
+        canvasesDrivenByVtkJs.push(canvas);
+        const internalViewportEntry = { ...viewportInputEntry, canvas };
+        this.addVtkjsDrivenViewport(internalViewportEntry);
+    }
+    addVtkjsDrivenViewport(viewportInputEntry) {
+        const { element, canvas, viewportId, type, defaultOptions } = viewportInputEntry;
+        element.tabIndex = -1;
+        this.offscreenMultiRenderWindow.addRenderer({
+            viewport: [0, 0, 1, 1],
+            id: viewportId,
+            background: defaultOptions.background
+                ? defaultOptions.background
+                : [0, 0, 0],
+        });
+        const viewportInput = {
+            id: viewportId,
+            element,
+            renderingEngineId: this.id,
+            type,
+            canvas,
+            sx: 0,
+            sy: 0,
+            sWidth: canvas.width,
+            sHeight: canvas.height,
+            defaultOptions: defaultOptions || {},
+        };
+        let viewport;
+        if (type === ViewportType.STACK) {
+            viewport = new StackViewport(viewportInput);
+        }
+        else if (type === ViewportType.ORTHOGRAPHIC ||
+            type === ViewportType.PERSPECTIVE) {
+            viewport = new VolumeViewport(viewportInput);
+        }
+        else if (type === ViewportType.VOLUME_3D) {
+            viewport = new VolumeViewport3D(viewportInput);
+        }
+        else {
+            throw new Error(`Viewport Type ${type} is not supported`);
+        }
+        this._viewports.set(viewportId, viewport);
+        const eventDetail = {
+            element,
+            viewportId,
+            renderingEngineId: this.id,
+        };
+        if (!viewport.suppressEvents) {
+            triggerEvent(eventTarget, Events.ELEMENT_ENABLED, eventDetail);
+        }
+    }
+    setVtkjsDrivenViewports(viewportInputEntries) {
+        if (viewportInputEntries.length) {
+            const vtkDrivenCanvases = viewportInputEntries.map((vp) => getOrCreateCanvas(vp.element));
+            vtkDrivenCanvases.forEach((canvas) => {
+                const devicePixelRatio = window.devicePixelRatio || 1;
+                const rect = canvas.getBoundingClientRect();
+                canvas.width = rect.width * devicePixelRatio;
+                canvas.height = rect.height * devicePixelRatio;
+            });
+            for (let i = 0; i < viewportInputEntries.length; i++) {
+                const vtkDrivenViewportInputEntry = viewportInputEntries[i];
+                const canvas = vtkDrivenCanvases[i];
+                const internalViewportEntry = {
+                    ...vtkDrivenViewportInputEntry,
+                    canvas,
+                };
+                this.addVtkjsDrivenViewport(internalViewportEntry);
+            }
+        }
+    }
+    _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
+        const canvasesDrivenByVtkJs = vtkDrivenViewports.map((vp) => {
+            return getOrCreateCanvas(vp.element);
+        });
+        canvasesDrivenByVtkJs.forEach((canvas) => {
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            canvas.width = canvas.clientWidth * devicePixelRatio;
+            canvas.height = canvas.clientHeight * devicePixelRatio;
+        });
+        if (canvasesDrivenByVtkJs.length) {
+            this._resize(vtkDrivenViewports);
+        }
+        vtkDrivenViewports.forEach((vp) => {
+            const prevCamera = vp.getCamera();
+            const rotation = vp.getRotation();
+            const { flipHorizontal } = prevCamera;
+            vp.resetCameraForResize();
+            const displayArea = vp.getDisplayArea();
+            if (keepCamera) {
+                if (displayArea) {
+                    if (flipHorizontal) {
+                        vp.setCamera({ flipHorizontal });
+                    }
+                    if (rotation) {
+                        vp.setViewPresentation({ rotation });
+                    }
+                }
+                else {
+                    vp.setCamera(prevCamera);
+                }
+            }
+        });
+        if (immediate) {
+            this.render();
+        }
+    }
+    renderViewportUsingCustomOrVtkPipeline(viewport) {
+        let eventDetail;
+        if (viewport.sWidth < VIEWPORT_MIN_SIZE ||
+            viewport.sHeight < VIEWPORT_MIN_SIZE) {
+            console.warn('Viewport is too small', viewport.sWidth, viewport.sHeight);
+            return;
+        }
+        if (viewportTypeUsesCustomRenderingPipeline(viewport.type) === true) {
+            eventDetail =
+                viewport.customRenderViewportToCanvas();
+        }
+        else {
+            if (this.useCPURendering) {
+                throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
+            }
+            const { offscreenMultiRenderWindow } = this;
+            const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+            this._resizeOffScreenCanvasForSingleViewport(viewport.canvas);
+            const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
+            renderer.setViewport([0, 0, 1, 1]);
+            const allRenderers = offscreenMultiRenderWindow.getRenderers();
+            allRenderers.forEach(({ renderer: r, id }) => {
+                r.setDraw(id === viewport.id);
+            });
+            const widgetRenderers = this.getWidgetRenderers();
+            widgetRenderers.forEach((viewportId, renderer) => {
+                renderer.setDraw(viewportId === viewport.id);
+            });
+            renderWindow.render();
+            allRenderers.forEach(({ renderer: r }) => r.setDraw(false));
+            const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
+            const context = openGLRenderWindow.get3DContext();
+            const offScreenCanvas = context.canvas;
+            eventDetail = this._renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas);
+        }
+        return eventDetail;
+    }
+    _renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas) {
+        const { element, canvas, id: viewportId, renderingEngineId, suppressEvents, } = viewport;
+        const { width: dWidth, height: dHeight } = canvas;
+        const onScreenContext = canvas.getContext('2d');
+        onScreenContext.drawImage(offScreenCanvas, 0, 0, dWidth, dHeight, 0, 0, dWidth, dHeight);
+        return {
+            element,
+            suppressEvents,
+            viewportId,
+            renderingEngineId,
+            viewportStatus: viewport.viewportStatus,
+        };
+    }
+    _resizeOffScreenCanvasForSingleViewport(currentViewport) {
+        const { offScreenCanvasContainer, offscreenMultiRenderWindow } = this;
+        const offScreenCanvasWidth = currentViewport.width;
+        const offScreenCanvasHeight = currentViewport.height;
+        offScreenCanvasContainer.width = offScreenCanvasWidth;
+        offScreenCanvasContainer.height = offScreenCanvasHeight;
+        offscreenMultiRenderWindow.resize();
+        return { offScreenCanvasWidth, offScreenCanvasHeight };
+    }
+    _resize(viewportsDrivenByVtkJs) {
+        for (const viewport of viewportsDrivenByVtkJs) {
+            viewport.sx = 0;
+            viewport.sy = 0;
+            viewport.sWidth = viewport.canvas.width;
+            viewport.sHeight = viewport.canvas.height;
+            const renderer = this.offscreenMultiRenderWindow.getRenderer(viewport.id);
+            renderer.setViewport([0, 0, 1, 1]);
+        }
+    }
+    getWidgetRenderers() {
+        const allViewports = this._getViewportsAsArray();
+        const widgetRenderers = new Map();
+        allViewports.forEach((vp) => {
+            const widgets = vp.getWidgets ? vp.getWidgets() : [];
+            widgets.forEach((widget) => {
+                const renderer = widget.getRenderer ? widget.getRenderer() : null;
+                if (renderer) {
+                    widgetRenderers.set(renderer, vp.id);
+                }
+            });
+        });
+        return widgetRenderers;
+    }
+}
+export default SequentialRenderingEngine;

package/dist/esm/RenderingEngine/StackViewport.d.ts

@@ -181,7 +181,9 @@ declare class StackViewport extends Viewport {
     jumpToWorld(worldPos: Point3): boolean;
     private canvasToWorldCPU;
     private worldToCanvasCPU;
+    private canvasToWorldGPUSequential;
     private canvasToWorldGPU;
+    private worldToCanvasGPUSequential;
     private worldToCanvasGPU;
     private _getVOIRangeForCurrentImage;
     private _getValidVOILUTFunction;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -43,6 +43,7 @@ import uuidv4 from '../utilities/uuidv4';
 import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
 import getClosestImageId from '../utilities/getClosestImageId';
 import { adjustInitialViewUp } from '../utilities/adjustInitialViewUp';
+import { isSequentialRenderingEngine } from './helpers/isSequentialRenderingEngine';
 const EPSILON = 1;
 const log = coreLog.getLogger('RenderingEngine', 'StackViewport');
 class StackViewport extends Viewport {
@@ -195,6 +196,30 @@ class StackViewport extends Viewport {
             const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, indexPoint);
             return canvasPoint;
         };
+        this.canvasToWorldGPUSequential = (canvasPos) => {
+            const renderer = this.getRenderer();
+            const vtkCamera = this.getVtkActiveCamera();
+            const crange = vtkCamera.getClippingRange();
+            const distance = vtkCamera.getDistance();
+            vtkCamera.setClippingRange(distance, distance + 0.1);
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const { width, height } = this.canvas;
+            const aspectRatio = width / height;
+            const canvasPosWithDPR = [
+                canvasPos[0] * devicePixelRatio,
+                canvasPos[1] * devicePixelRatio,
+            ];
+            const normalizedDisplay = [
+                canvasPosWithDPR[0] / width,
+                1 - canvasPosWithDPR[1] / height,
+                0,
+            ];
+            const projCoords = renderer.normalizedDisplayToProjection(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2]);
+            const viewCoords = renderer.projectionToView(projCoords[0], projCoords[1], projCoords[2], aspectRatio);
+            const worldCoord = renderer.viewToWorld(viewCoords[0], viewCoords[1], viewCoords[2]);
+            vtkCamera.setClippingRange(crange[0], crange[1]);
+            return [worldCoord[0], worldCoord[1], worldCoord[2]];
+        };
         this.canvasToWorldGPU = (canvasPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
@@ -218,6 +243,27 @@ class StackViewport extends Viewport {
             vtkCamera.setClippingRange(crange[0], crange[1]);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
+        this.worldToCanvasGPUSequential = (worldPos) => {
+            const renderer = this.getRenderer();
+            const vtkCamera = this.getVtkActiveCamera();
+            const crange = vtkCamera.getClippingRange();
+            const distance = vtkCamera.getDistance();
+            vtkCamera.setClippingRange(distance, distance + 0.1);
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const { width, height } = this.canvas;
+            const aspectRatio = width / height;
+            const viewCoords = renderer.worldToView(worldPos[0], worldPos[1], worldPos[2]);
+            const projCoords = renderer.viewToProjection(viewCoords[0], viewCoords[1], viewCoords[2], aspectRatio);
+            const normalizedDisplay = renderer.projectionToNormalizedDisplay(projCoords[0], projCoords[1], projCoords[2]);
+            const canvasX = normalizedDisplay[0] * width;
+            const canvasY = (1 - normalizedDisplay[1]) * height;
+            vtkCamera.setClippingRange(crange[0], crange[1]);
+            const canvasCoordWithDPR = [
+                canvasX / devicePixelRatio,
+                canvasY / devicePixelRatio,
+            ];
+            return canvasCoordWithDPR;
+        };
         this.worldToCanvasGPU = (worldPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
@@ -344,11 +390,17 @@ class StackViewport extends Viewport {
             },
             canvasToWorld: {
                 cpu: this.canvasToWorldCPU,
-                gpu: this.canvasToWorldGPU,
+                gpu: {
+                    sequential: this.canvasToWorldGPUSequential,
+                    default: this.canvasToWorldGPU,
+                },
             },
             worldToCanvas: {
                 cpu: this.worldToCanvasCPU,
-                gpu: this.worldToCanvasGPU,
+                gpu: {
+                    sequential: this.worldToCanvasGPUSequential,
+                    default: this.worldToCanvasGPU,
+                },
             },
             getRenderer: {
                 cpu: () => this.getCPUFallbackError('getRenderer'),
@@ -407,11 +459,27 @@ class StackViewport extends Viewport {
         return getShouldUseCPURendering();
     }
     _configureRenderingPipeline(value) {
+        const renderingEngine = this.getRenderingEngine();
+        const isSequential = isSequentialRenderingEngine(renderingEngine);
         this.useCPURendering = value ?? getShouldUseCPURendering();
         for (const key in this.renderingPipelineFunctions) {
             if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
                 const functions = this.renderingPipelineFunctions[key];
-                this[key] = this.useCPURendering ? functions.cpu : functions.gpu;
+                if (this.useCPURendering) {
+                    this[key] = functions.cpu;
+                }
+                else {
+                    if (typeof functions.gpu === 'object' &&
+                        functions.gpu.sequential &&
+                        functions.gpu.default) {
+                        this[key] = isSequential
+                            ? functions.gpu.sequential
+                            : functions.gpu.default;
+                    }
+                    else {
+                        this[key] = functions.gpu;
+                    }
+                }
             }
         }
         const result = this.useCPURendering

package/dist/esm/RenderingEngine/StandardRenderingEngine.d.ts

@@ -0,0 +1,23 @@
+import BaseRenderingEngine from './BaseRenderingEngine';
+import type IStackViewport from '../types/IStackViewport';
+import type IVolumeViewport from '../types/IVolumeViewport';
+import type * as EventTypes from '../types/EventTypes';
+import type { InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
+declare class StandardRenderingEngine extends BaseRenderingEngine {
+    protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
+    protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput, offscreenCanvasProperties?: {
+        offScreenCanvasWidth: number;
+        offScreenCanvasHeight: number;
+        xOffset: number;
+    }): void;
+    protected setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
+    protected _resizeVTKViewports(vtkDrivenViewports: (IStackViewport | IVolumeViewport)[], keepCamera?: boolean, immediate?: boolean): void;
+    protected _renderFlaggedViewports: () => void;
+    private performVtkDrawCall;
+    protected renderViewportUsingCustomOrVtkPipeline(viewport: IViewport): EventTypes.ImageRenderedEventDetail;
+    protected _renderViewportFromVtkCanvasToOnscreenCanvas(viewport: IViewport, offScreenCanvas: HTMLCanvasElement): EventTypes.ImageRenderedEventDetail;
+    private _resizeOffScreenCanvas;
+    private _resize;
+    private _getViewportCoordsOnOffScreenCanvas;
+}
+export default StandardRenderingEngine;