@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

package/dist/esm/RenderingEngine/TiledRenderingEngine.js

@@ -2,19 +2,16 @@ 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';
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
+import { getViewportClassForInput } from './helpers/viewportTypeToViewportClass';
 class TiledRenderingEngine extends BaseRenderingEngine {
     constructor(id) {
         super(id);
         this._renderFlaggedViewports = () => {
             this._throwIfDestroyed();
-            if (!this.useCPURendering) {
+            if (this.offscreenMultiRenderWindow) {
                 this.performVtkDrawCall();
             }
             const viewports = this._getViewportsAsArray();
@@ -41,6 +38,11 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             });
         };
         if (!this.useCPURendering) {
+            this.ensureOffscreenResources();
+        }
+    }
+    ensureOffscreenResources() {
+        if (!this.offscreenMultiRenderWindow) {
             this.offscreenMultiRenderWindow =
                 vtkOffscreenMultiRenderWindow.newInstance();
             this.offScreenCanvasContainer = document.createElement('div');
@@ -48,6 +50,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         }
     }
     enableVTKjsDrivenViewport(viewportInputEntry) {
+        this.ensureOffscreenResources();
         const viewports = this._getViewportsAsArray();
         const viewportsDrivenByVtkJs = viewports.filter((vp) => viewportTypeUsesCustomRenderingPipeline(vp.type) === false);
         const canvasesDrivenByVtkJs = viewportsDrivenByVtkJs.map((vp) => vp.canvas);
@@ -63,6 +66,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         });
     }
     addVtkjsDrivenViewport(viewportInputEntry, offscreenCanvasProperties) {
+        this.ensureOffscreenResources();
         const { element, canvas, viewportId, type, defaultOptions } = viewportInputEntry;
         element.tabIndex = -1;
         const { offScreenCanvasWidth, offScreenCanvasHeight, xOffset } = offscreenCanvasProperties;
@@ -91,20 +95,12 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             sHeight,
             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 {
+        const ViewportClass = getViewportClassForInput(viewportInputEntry);
+        if (!ViewportClass) {
             throw new Error(`Viewport Type ${type} is not supported`);
         }
+        const viewport = new ViewportClass(viewportInput);
+        viewport.requestedType = viewportInputEntry.requestedType ?? type;
         this._viewports.set(viewportId, viewport);
         const eventDetail = {
             element,
@@ -159,7 +155,13 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             const prevCamera = vp.getCamera();
             const rotation = vp.getRotation();
             const { flipHorizontal } = prevCamera;
-            vp.resetCameraForResize();
+            const resizeResetViewport = vp;
+            if (resizeResetViewport.resetViewStateForResize) {
+                resizeResetViewport.resetViewStateForResize();
+            }
+            else {
+                resizeResetViewport.resetCameraForResize();
+            }
             const displayArea = vp.getDisplayArea();
             if (keepCamera) {
                 if (displayArea) {
@@ -188,7 +190,8 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         }
         for (let i = 0; i < renderers.length; i++) {
             const { renderer, id } = renderers[i];
-            if (this._needsRender.has(id)) {
+            const viewportId = id.split('::')[0];
+            if (this._needsRender.has(viewportId)) {
                 renderer.setDraw(true);
             }
             else {
@@ -212,7 +215,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
                 viewport.customRenderViewportToCanvas();
         }
         else {
-            if (this.useCPURendering) {
+            if (!this.offscreenMultiRenderWindow) {
                 throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
             }
             const { offscreenMultiRenderWindow } = this;

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

@@ -38,20 +38,12 @@ declare class VideoViewport extends Viewport {
     private addEventListeners;
     private removeEventListeners;
     private elementDisabledHandler;
-    getImageDataMetadata(image: IImage | string): {
-        bitsAllocated: number;
-        numberOfComponents: number;
-        origin: any;
-        rows: any;
-        columns: any;
-        direction: number[];
-        dimensions: any[];
-        spacing: any[];
-        hasPixelSpacing: boolean;
-        numVoxels: number;
-        imagePlaneModule: any;
-    };
+    getImageDataMetadata(image: IImage | string): import("../utilities/VideoUtilities").VideoImageMetadata;
     setDataIds(imageIds: string[], options?: ImageSetOptions): void;
+    setDataList(entries: Array<{
+        dataId: string;
+        options?: Record<string, unknown>;
+    }>): Promise<unknown>;
     setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
     private setVideoURL;
     getImageIds(): string[];

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -1,6 +1,4 @@
-import { vec3 } from 'gl-matrix';
-import { Events as EVENTS, VideoEnums as VideoViewportEnum, MetadataModules, } from '../enums';
-import * as metaData from '../metaData';
+import { Events as EVENTS, VideoEnums as VideoViewportEnum } from '../enums';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
@@ -10,8 +8,8 @@ import cache from '../cache/cache';
 import uuidv4 from '../utilities/uuidv4';
 import FrameRange from '../utilities/FrameRange';
 import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
+import { getVideoImageDataMetadata, loadVideoStreamMetadata, normalizeVideoPlaybackInfo, } from '../utilities/VideoUtilities';
 class VideoViewport extends Viewport {
-    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {
         super({
             ...props,
@@ -125,6 +123,7 @@ class VideoViewport extends Viewport {
                 actor.actor.render(this, this.canvasContext);
             }
             this.canvasContext.resetTransform();
+            this.setRendered();
             triggerEvent(this.element, EVENTS.STACK_NEW_IMAGE, {
                 element: this.element,
                 viewportId: this.id,
@@ -192,69 +191,34 @@ class VideoViewport extends Viewport {
     }
     getImageDataMetadata(image) {
         const imageId = typeof image === 'string' ? image : image.imageId;
-        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
-        let rowCosines = imagePlaneModule.rowCosines;
-        let columnCosines = imagePlaneModule.columnCosines;
-        const usingDefaultValues = imagePlaneModule.usingDefaultValues;
-        if (usingDefaultValues || rowCosines == null || columnCosines == null) {
-            rowCosines = [1, 0, 0];
-            columnCosines = [0, 1, 0];
-        }
-        const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
-        const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-        const { rows, columns } = imagePlaneModule;
-        const scanAxisNormal = vec3.create();
-        vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
-        let origin = imagePlaneModule.imagePositionPatient;
-        if (origin == null) {
-            origin = [0, 0, 0];
-        }
-        const xSpacing = imagePlaneModule.columnPixelSpacing || 1;
-        const ySpacing = imagePlaneModule.rowPixelSpacing || 1;
-        const xVoxels = imagePlaneModule.columns;
-        const yVoxels = imagePlaneModule.rows;
-        const zSpacing = 1;
-        const zVoxels = 1;
-        this.hasPixelSpacing = !!imagePlaneModule.columnPixelSpacing;
-        return {
-            bitsAllocated: 8,
-            numberOfComponents: 3,
-            origin,
-            rows,
-            columns,
-            direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
-            dimensions: [xVoxels, yVoxels, zVoxels],
-            spacing: [xSpacing, ySpacing, zSpacing],
-            hasPixelSpacing: this.hasPixelSpacing,
-            numVoxels: xVoxels * yVoxels * zVoxels,
-            imagePlaneModule,
-        };
+        const metadata = getVideoImageDataMetadata(imageId);
+        this.hasPixelSpacing = metadata.hasPixelSpacing;
+        return metadata;
     }
     setDataIds(imageIds, options) {
         this.setVideo(imageIds[0], (options.viewReference?.sliceIndex || 0) + 1);
     }
+    setDataList(entries) {
+        if (!entries.length) {
+            return;
+        }
+        return this.setVideo(entries[0].dataId);
+    }
     setVideo(imageId, frameNumber) {
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
-        const imageUrlModule = metaData.get(MetadataModules.IMAGE_URL, imageId);
-        if (!imageUrlModule?.rendered) {
-            throw new Error(`Video Image ID ${imageId} does not have a rendered video view`);
-        }
-        const { rendered } = imageUrlModule;
-        const generalSeries = metaData.get(MetadataModules.GENERAL_SERIES, imageId);
-        this.modality = generalSeries?.Modality;
-        this.metadata = this.getImageDataMetadata(imageId);
-        let { cineRate, numberOfFrames } = metaData.get(MetadataModules.CINE, imageId);
-        this.numberOfFrames = numberOfFrames;
-        return this.setVideoURL(rendered).then(() => {
-            if (!numberOfFrames || numberOfFrames === 1) {
-                numberOfFrames = Math.round(this.videoElement.duration * (cineRate || 30));
-            }
-            if (!cineRate) {
-                cineRate = Math.round(numberOfFrames / this.videoElement.duration);
-            }
-            this.fps = cineRate;
-            this.numberOfFrames = numberOfFrames;
-            this.setFrameRange([1, numberOfFrames]);
+        const stream = loadVideoStreamMetadata(imageId);
+        this.modality = stream.modality;
+        this.metadata = stream.metadata;
+        this.numberOfFrames = stream.numberOfFrames;
+        return this.setVideoURL(stream.renderedUrl).then(() => {
+            const playbackInfo = normalizeVideoPlaybackInfo({
+                durationSeconds: this.videoElement.duration,
+                cineRate: stream.cineRate,
+                numberOfFrames: stream.numberOfFrames,
+            });
+            this.fps = playbackInfo.fps;
+            this.numberOfFrames = playbackInfo.numberOfFrames;
+            this.setFrameRange(playbackInfo.frameRange);
             this.initialRender = () => {
                 this.initialRender = null;
                 this.pause();
@@ -308,7 +272,7 @@ class VideoViewport extends Viewport {
                 this.renderWhilstPlaying();
             }
         }
-        catch (e) {
+        catch (_error) {
         }
     }
     pause() {
@@ -316,7 +280,7 @@ class VideoViewport extends Viewport {
             this.isPlaying = false;
             this.videoElement.pause();
         }
-        catch (e) {
+        catch {
         }
     }
     async scroll(delta = 1) {
@@ -326,7 +290,7 @@ class VideoViewport extends Viewport {
         const currentTime = videoElement.currentTime;
         const newTime = currentTime + (delta * this.scrollSpeed) / this.fps;
         videoElement.currentTime = newTime;
-        const seekEventListener = (evt) => {
+        const seekEventListener = () => {
             renderFrame();
             videoElement.removeEventListener('seeked', seekEventListener);
         };
@@ -337,7 +301,7 @@ class VideoViewport extends Viewport {
         const renderFrame = this.renderFrame;
         videoElement.currentTime = 0;
         if (videoElement.paused) {
-            const seekEventListener = (evt) => {
+            const seekEventListener = () => {
                 renderFrame();
                 videoElement.removeEventListener('seeked', seekEventListener);
             };
@@ -349,7 +313,7 @@ class VideoViewport extends Viewport {
         const renderFrame = this.renderFrame;
         videoElement.currentTime = videoElement.duration;
         if (videoElement.paused) {
-            const seekEventListener = (evt) => {
+            const seekEventListener = () => {
                 renderFrame();
                 videoElement.removeEventListener('seeked', seekEventListener);
             };
@@ -361,7 +325,7 @@ class VideoViewport extends Viewport {
         const renderFrame = this.renderFrame;
         videoElement.currentTime = timeInSeconds;
         if (videoElement.paused) {
-            const seekEventListener = (evt) => {
+            const seekEventListener = () => {
                 renderFrame();
                 videoElement.removeEventListener('seeked', seekEventListener);
             };
@@ -578,7 +542,7 @@ class VideoViewport extends Viewport {
         return current;
     }
     getViewReferenceId(specifier = {}) {
-        const { sliceIndex: sliceIndex } = specifier;
+        const { sliceIndex } = specifier;
         if (sliceIndex === undefined) {
             return `videoId:${this.getCurrentImageId()}`;
         }
@@ -748,4 +712,5 @@ class VideoViewport extends Viewport {
         return new CanvasActor(this, image);
     }
 }
+VideoViewport.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i;
 export default VideoViewport;

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

@@ -4,7 +4,7 @@ import type { mat4 } from 'gl-matrix';
 import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import type { ICamera, ActorEntry, IRenderingEngine, ViewportInputOptions, Point2, Point3, FlipDirection, DisplayArea, ViewPresentation, ViewReference, ViewportProperties, ImageActor } from '../types';
-import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions, PlaneRestriction } from '../types/IViewport';
+import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions, PlaneRestriction, RenderingEngineResizeOptions } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
 import type IImageCalibration from '../types/IImageCalibration';
 import { InterpolationType } from '../enums';
@@ -17,6 +17,7 @@ declare class Viewport {
     readonly canvas: HTMLCanvasElement;
     readonly renderingEngineId: string;
     readonly type: ViewportType;
+    requestedType?: ViewportType;
     protected insetImageMultiplier: number;
     protected flipHorizontal: boolean;
     protected flipVertical: boolean;
@@ -47,13 +48,19 @@ declare class Viewport {
     getNumberOfSlices: () => number;
     protected setRotation: (_rotation: number) => void;
     static get useCustomRenderingPipeline(): boolean;
+    getUseCustomRenderingPipeline(): boolean;
+    resizeForRenderingEngine({ keepCamera, }?: RenderingEngineResizeOptions): void;
+    isOrientationChangeable(): boolean;
     private viewportWidgets;
     addWidget: (widgetId: any, widget: any) => void;
     getWidget: (id: any) => any;
     getWidgets: () => any[];
     getRenderPasses: () => any;
     removeWidgets: () => void;
+    dispose(): void;
+    destroy(): void;
     setRendered(): void;
+    setNeedsRender(): void;
     protected setColorTransform(voiRange: any, averageWhite: any): any;
     getRenderingEngine(): IRenderingEngine;
     getRenderer(): vtkRenderer;
@@ -98,22 +105,26 @@ declare class Viewport {
         resetZoom?: boolean;
         resetToCenter?: boolean;
         storeAsInitialCamera?: boolean;
+        resetAspectRatio?: boolean;
     }): boolean;
     protected setInitialCamera(camera: ICamera): void;
     protected setFitToCanvasCamera(camera: ICamera): void;
-    getPan(initialCamera?: ICamera): Point2;
+    getPan(initialCamera?: ICamera<number>): Point2;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
     getImageData(): any;
     getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
     setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
-    getZoom(compareCamera?: ICamera): number;
+    getZoom(compareCamera?: ICamera<number>): number;
     setZoom(value: number, storeAsInitialCamera?: boolean): void;
+    getAspectRatio(): Point2;
+    setAspectRatio(value: Point2, isFitViewportAfterStretch?: boolean, storeAsInitialCamera?: boolean): void;
     private _getFocalPointForViewPlaneReset;
     getCanvas(): HTMLCanvasElement;
     protected getVtkActiveCamera(): vtkCamera | vtkSlabCamera;
     protected getCameraNoRotation(): ICamera;
     getCamera(): ICamera;
+    private setAspectRatioForVTKCamera;
     setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
     triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void;
     updateCameraClippingPlanesAndRange(): void;
@@ -125,7 +136,7 @@ declare class Viewport {
     isPlaneViewable(planeRestriction: PlaneRestriction, options?: ReferenceCompatibleOptions): boolean;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
-    setViewReference(viewRef: ViewReference): void;
+    setViewReference(_viewRef: ViewReference): void;
     setViewPresentation(viewPres: ViewPresentation): void;
     _getCorners(bounds: number[]): number[][];
     _getFocalPointForResetCamera(centeredFocalPoint: Point3, previousCamera: ICamera, { resetPan, resetToCenter }: {
@@ -135,6 +146,10 @@ declare class Viewport {
     _isInBounds(point: Point3, bounds: number[]): boolean;
     _getEdges(bounds: number[]): [number[], number[]][];
     static boundsRadius(bounds: number[]): number;
-    setDataIds(_imageIds: string[], _options?: DataSetOptions): void;
+    setDataList(_entries: Array<{
+        dataId: string;
+        options?: DataSetOptions;
+    }>): void;
 }
+export declare function getVolumeCenterIJK(dimensions: number[], direction: ArrayLike<number>, viewPlaneNormal: ArrayLike<number>): number[];
 export default Viewport;