@cornerstonejs/core 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -2,11 +2,11 @@ import { vec3 } from 'gl-matrix';
 import { Events as EVENTS, VideoEnums as VideoViewportEnum, MetadataModules, } from '../enums';
 import * as metaData from '../metaData';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
-import cache from '../cache';
+import cache from '../cache/cache';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {
@@ -23,7 +23,6 @@ class VideoViewport extends Viewport {
         this.playbackRate = 1;
         this.frameRange = [0, 0];
         this.fps = 30;
-        this.numberOfFrames = 0;
         this.videoCamera = {
             panWorld: [0, 0],
             parallelScale: 1,
@@ -41,16 +40,21 @@ class VideoViewport extends Viewport {
                 voiRange: { ...this.voiRange },
             };
         };
+        this.getMiddleSliceData = () => {
+            throw new Error('Method not implemented.');
+        };
+        this.useCustomRenderingPipeline = true;
         this.resetCamera = () => {
             this.refreshRenderValues();
             this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
-            if (this.isPlaying === false) {
+            if (!this.isPlaying) {
                 this.renderFrame();
             }
             return true;
         };
         this.getNumberOfSlices = () => {
-            return Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            const computedSlices = Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            return isNaN(computedSlices) ? this.numberOfFrames : computedSlices;
         };
         this.getFrameOfReferenceUID = () => {
             return this.videoElement.src;
@@ -63,7 +67,7 @@ class VideoViewport extends Viewport {
                 canvas.height = clientHeight;
             }
             this.refreshRenderValues();
-            if (this.isPlaying === false) {
+            if (!this.isPlaying) {
                 this.renderFrame();
             }
         };
@@ -98,7 +102,9 @@ class VideoViewport extends Viewport {
         };
         this.indexToCanvas = (indexPos) => {
             const transform = this.getTransform();
-            return (transform.transformPoint(indexPos).map((it) => it / devicePixelRatio));
+            return transform
+                .transformPoint(indexPos)
+                .map((it) => it / devicePixelRatio);
         };
         this.customRenderViewportToCanvas = () => {
             this.renderFrame();
@@ -109,7 +115,7 @@ class VideoViewport extends Viewport {
             const ctx = this.canvasContext;
             ctx.resetTransform();
             ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
-            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth, this.videoHeight);
+            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth || 1024, this.videoHeight || 1024);
             for (const actor of this.getActors()) {
                 actor.actor.render(this, this.canvasContext);
             }
@@ -126,11 +132,13 @@ class VideoViewport extends Viewport {
                 element: this.element,
                 viewportId: this.id,
                 viewport: this,
+                imageIndex: this.getCurrentImageIdIndex(),
+                numberOfSlices: this.numberOfFrames,
                 renderingEngineId: this.renderingEngineId,
                 time: this.videoElement.currentTime,
                 duration: this.videoElement.duration,
             });
-            this.initialRender?.();
+            this.initialRender();
             const frame = this.getFrameNumber();
             if (this.isPlaying) {
                 if (frame < this.frameRange[0]) {
@@ -204,7 +212,7 @@ class VideoViewport extends Viewport {
         this.hasPixelSpacing = !!imagePlaneModule.columnPixelSpacing;
         return {
             bitsAllocated: 8,
-            numComps: 3,
+            numberOfComponents: 3,
             origin,
             rows,
             columns,
@@ -216,15 +224,23 @@ class VideoViewport extends Viewport {
             imagePlaneModule,
         };
     }
+    setDataIds(imageIds, options) {
+        this.setVideo(imageIds[0], (options.viewReference.sliceIndex || 0) + 1);
+    }
     setVideo(imageId, frameNumber) {
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
-        const { rendered } = metaData.get(MetadataModules.IMAGE_URL, 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(() => {
-            let { cineRate, numberOfFrames } = metaData.get(MetadataModules.CINE, imageId);
-            if (!numberOfFrames) {
+            if (!numberOfFrames || numberOfFrames === 1) {
                 numberOfFrames = Math.round(this.videoElement.duration * (cineRate || 30));
             }
             if (!cineRate) {
@@ -281,18 +297,18 @@ class VideoViewport extends Viewport {
     async play() {
         try {
             if (!this.isPlaying) {
-                await this.videoElement.play();
                 this.isPlaying = true;
+                await this.videoElement.play();
                 this.renderWhilstPlaying();
             }
         }
         catch (e) {
         }
     }
-    async pause() {
+    pause() {
         try {
-            await this.videoElement.pause();
             this.isPlaying = false;
+            this.videoElement.pause();
         }
         catch (e) {
         }
@@ -346,6 +362,9 @@ class VideoViewport extends Viewport {
             videoElement.addEventListener('seeked', seekEventListener);
         }
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     async setFrameNumber(frame) {
         this.setTime((frame - 1) / this.fps);
     }
@@ -404,7 +423,7 @@ class VideoViewport extends Viewport {
         });
     }
     getScalarData() {
-        if (this.scalarData?.frameNumber === this.getFrameNumber()) {
+        if (this.scalarData.frameNumber === this.getFrameNumber()) {
             return this.scalarData;
         }
         const canvas = document.createElement('canvas');
@@ -427,8 +446,12 @@ class VideoViewport extends Viewport {
             spacing,
             origin: metadata.origin,
             direction: metadata.direction,
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: metadata.FrameOfReferenceUID,
+            },
             getScalarData: () => this.getScalarData(),
+            scalarData: this.getScalarData(),
             imageData: {
                 getDirection: () => metadata.direction,
                 getDimensions: () => metadata.dimensions,
@@ -462,7 +485,7 @@ class VideoViewport extends Viewport {
         const testURI = framesMatch
             ? imageURI.substring(0, framesMatch.index)
             : imageURI;
-        return this.imageId.indexOf(testURI) !== -1;
+        return this.imageId.includes(testURI);
     }
     setVOI(voiRange) {
         this.voiRange = voiRange;
@@ -527,7 +550,7 @@ class VideoViewport extends Viewport {
         }
         this.canvasContext.fillStyle = 'rgba(0,0,0,1)';
         this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
-        if (this.isPlaying === false) {
+        if (!this.isPlaying) {
             this.renderFrame();
         }
     }
@@ -573,15 +596,23 @@ class VideoViewport extends Viewport {
             return false;
         }
         const match = referencedImageId.match(VideoViewport.frameRangeExtractor);
-        if (!match || !match[2]) {
+        if (!match[2]) {
             return true;
         }
         const range = match[2].split('-').map((it) => Number(it));
         const frame = currentIndex + 1;
         return range[0] <= frame && frame <= (range[1] ?? range[0]);
     }
+    setViewReference(viewRef) {
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.setFrameNumber(viewRef.sliceIndex + 1);
+        }
+        else if (Array.isArray(viewRef.sliceIndex)) {
+            this.setFrameRange(viewRef.sliceIndex);
+        }
+    }
     getViewReference(viewRefSpecifier) {
-        let sliceIndex = viewRefSpecifier?.sliceIndex;
+        let sliceIndex = viewRefSpecifier.sliceIndex;
         if (!sliceIndex) {
             sliceIndex = this.isPlaying
                 ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
@@ -600,7 +631,7 @@ class VideoViewport extends Viewport {
         return Math.round(this.videoElement.currentTime * this.fps);
     }
     getSliceIndex() {
-        return this.getCurrentImageIdIndex();
+        return this.getCurrentImageIdIndex() / this.scrollSpeed;
     }
     getCamera() {
         const { parallelScale } = this.videoCamera;
@@ -618,6 +649,9 @@ class VideoViewport extends Viewport {
             viewPlaneNormal: [0, 0, 1],
         };
     }
+    getFrameRate() {
+        return this.fps;
+    }
     getPan() {
         const panWorld = this.videoCamera.panWorld;
         return [panWorld[0], panWorld[1]];
@@ -673,7 +707,10 @@ class VideoViewport extends Viewport {
             if (imageActor) {
                 actors.push({ uid: stackInput.actorUID, actor: imageActor });
                 if (stackInput.callback) {
-                    stackInput.callback({ imageActor, imageId: stackInput.imageId });
+                    stackInput.callback({
+                        imageActor: imageActor,
+                        imageId: stackInput.imageId,
+                    });
                 }
             }
         });

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

@@ -1,12 +1,14 @@
 import type { vtkCamera } from '@kitware/vtk.js/Rendering/Core/Camera';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+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 } from '../types';
-import type { ViewportInput, IViewport, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector } from '../types/IViewport';
+import type { ViewportInput, IViewport, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
-import IImageCalibration from '../types/IImageCalibration';
+import type IImageCalibration from '../types/IImageCalibration';
 import { InterpolationType } from '../enums';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 declare class Viewport implements IViewport {
     static readonly CameraViewPresentation: ViewPresentationSelector;
     static readonly TransferViewPresentation: ViewPresentationSelector;
@@ -24,8 +26,8 @@ declare class Viewport implements IViewport {
     sy: number;
     sWidth: number;
     sHeight: number;
-    _actors: Map<string, any>;
-    readonly defaultOptions: Record<string, any>;
+    _actors: Map<string, ActorEntry>;
+    readonly defaultOptions: ViewportInputOptions;
     options: ViewportInputOptions;
     _suppressCameraModifiedEvents: boolean;
     readonly suppressEvents: boolean;
@@ -52,22 +54,30 @@ declare class Viewport implements IViewport {
     removeWidgets: () => void;
     setRendered(): void;
     getRenderingEngine(): IRenderingEngine;
-    getRenderer(): any;
+    getRenderer(): vtkRenderer;
     render(): void;
     setOptions(options: ViewportInputOptions, immediate?: boolean): void;
     reset(immediate?: boolean): void;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
     protected flip({ flipHorizontal, flipVertical }: FlipDirection): void;
     private getDefaultImageData;
     getDefaultActor(): ActorEntry;
-    getActors(): Array<ActorEntry>;
-    getActorUIDs(): Array<string>;
+    getActors(): ActorEntry[];
+    getActorUIDs(): string[];
     getActor(actorUID: string): ActorEntry;
     getActorUIDByIndex(index: number): string;
     getActorByIndex(index: number): ActorEntry;
-    setActors(actors: Array<ActorEntry>): void;
+    setActors(actors: ActorEntry[]): void;
     _removeActor(actorUID: string): void;
-    removeActors(actorUIDs: Array<string>): void;
-    addActors(actors: Array<ActorEntry>, resetCameraPanAndZoom?: boolean): void;
+    removeActors(actorUIDs: string[]): void;
+    addActors(actors: ActorEntry[], resetCameraPanAndZoom?: boolean): void;
     addActor(actorEntry: ActorEntry): void;
     removeAllActors(): void;
     protected resetCameraNoEvent(): void;
@@ -84,6 +94,7 @@ declare class Viewport implements IViewport {
     getPan(initialCamera?: ICamera): Point2;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
+    getImageData(): any;
     getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
     setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
     getZoom(compareCamera?: ICamera): number;
@@ -97,7 +108,7 @@ declare class Viewport implements IViewport {
     triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void;
     updateCameraClippingPlanesAndRange(): void;
     protected updateClippingPlanesForActors(updatedCamera: ICamera): Promise<void>;
-    setOrientationOfClippingPlanes(vtkPlanes: Array<vtkPlane>, slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void;
+    setOrientationOfClippingPlanes(vtkPlanes: vtkPlane[], slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void;
     getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
     private _getWorldDistanceViewUpAndViewRight;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
@@ -105,14 +116,14 @@ declare class Viewport implements IViewport {
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): void;
     setViewPresentation(viewPres: ViewPresentation): void;
-    protected _shouldUseNativeDataType(): boolean;
-    _getCorners(bounds: Array<number>): Array<number>[];
+    _getCorners(bounds: number[]): number[][];
     _getFocalPointForResetCamera(centeredFocalPoint: Point3, previousCamera: ICamera, { resetPan, resetToCenter }: {
         resetPan?: boolean;
         resetToCenter?: boolean;
     }): Point3;
     _isInBounds(point: Point3, bounds: number[]): boolean;
-    _getEdges(bounds: Array<number>): Array<[number[], number[]]>;
+    _getEdges(bounds: number[]): [number[], number[]][];
     static boundsRadius(bounds: number[]): number;
+    setDataIds(_imageIds: string[], _options?: DataSetOptions): void;
 }
 export default Viewport;

package/dist/esm/RenderingEngine/Viewport.js

@@ -6,10 +6,12 @@ import Events from '../enums/Events';
 import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
-import { triggerEvent, planar, isImageActor, actorIsA, isEqual, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import triggerEvent from '../utilities/triggerEvent';
+import * as planar from '../utilities/planar';
+import isEqual from '../utilities/isEqual';
 import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
-import { getConfiguration } from '../init';
 import { InterpolationType } from '../enums';
 class Viewport {
     static { this.CameraViewPresentation = {
@@ -94,7 +96,7 @@ class Viewport {
         if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
             throw new Error('Rendering engine has been destroyed');
         }
-        return renderingEngine.offscreenMultiRenderWindow.getRenderer(this.id);
+        return renderingEngine.offscreenMultiRenderWindow?.getRenderer(this.id);
     }
     render() {
         const renderingEngine = this.getRenderingEngine();
@@ -115,6 +117,9 @@ class Viewport {
             this.render();
         }
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     flip({ flipHorizontal, flipVertical }) {
         const imageData = this.getDefaultImageData();
         if (!imageData) {
@@ -218,7 +223,9 @@ class Viewport {
             console.warn('Viewport::addActors::Rendering engine has not been initialized or has been destroyed');
             return;
         }
-        actors.forEach((actor) => this.addActor(actor));
+        actors.forEach((actor) => {
+            this.addActor(actor);
+        });
         this.resetCamera({
             resetPan: resetCameraPanAndZoom,
             resetZoom: resetCameraPanAndZoom,
@@ -476,11 +483,11 @@ class Viewport {
         renderer.invokeEvent(RESET_CAMERA_EVENT);
         this.triggerCameraModifiedEventIfNecessary(previousCamera, modifiedCamera);
         if (imageData &&
-            this.options?.displayArea &&
+            this.options.displayArea &&
             resetZoom &&
             resetPan &&
             resetToCenter) {
-            this.setDisplayArea(this.options?.displayArea);
+            this.setDisplayArea(this.options.displayArea);
         }
         return true;
     }
@@ -496,7 +503,7 @@ class Viewport {
         const zero3 = this.canvasToWorld([0, 0]);
         const initialCanvasFocal = this.worldToCanvas(vec3.subtract([0, 0, 0], initialCamera.focalPoint, zero3));
         const currentCanvasFocal = this.worldToCanvas(vec3.subtract([0, 0, 0], focalPoint, zero3));
-        const result = (vec2.subtract([0, 0], initialCanvasFocal, currentCanvasFocal));
+        const result = vec2.subtract([0, 0], initialCanvasFocal, currentCanvasFocal);
         return result;
     }
     getCurrentImageIdIndex() {
@@ -505,6 +512,9 @@ class Viewport {
     getSliceIndex() {
         throw new Error('Not implemented');
     }
+    getImageData() {
+        throw new Error('Not implemented');
+    }
     getViewReferenceId(_specifier) {
         return null;
     }
@@ -654,7 +664,7 @@ class Viewport {
             }
             if (cameraModifiedOutOfPlane || viewUpHasChanged) {
                 const actorEntry = this.getDefaultActor();
-                if (!actorEntry?.actor) {
+                if (!actorEntry.actor) {
                     return;
                 }
                 if (!actorIsA(actorEntry, 'vtkActor')) {
@@ -697,7 +707,7 @@ class Viewport {
             }
             const mapper = actorEntry.actor.getMapper();
             let vtkPlanes = actorEntry?.clippingFilter
-                ? actorEntry.clippingFilter.getClippingPlanes()
+                ? actorEntry?.clippingFilter.getClippingPlanes()
                 : mapper.getClippingPlanes();
             if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
                 vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
@@ -744,7 +754,7 @@ class Viewport {
         }
         const mapper = actorEntry.actor.getMapper();
         let vtkPlanes = actorEntry?.clippingFilter
-            ? actorEntry.clippingFilter.getClippingPlanes()
+            ? actorEntry?.clippingFilter.getClippingPlanes()
             : mapper.getClippingPlanes();
         if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
             vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
@@ -810,7 +820,7 @@ class Viewport {
         if (viewPlaneNormal &&
             !isEqual(viewPlaneNormal, camera.viewPlaneNormal) &&
             !isEqual(vec3.negate(camera.viewPlaneNormal, camera.viewPlaneNormal), viewPlaneNormal)) {
-            return options?.withOrientation === true;
+            return options?.withOrientation;
         }
         return true;
     }
@@ -856,10 +866,6 @@ class Viewport {
             this.setRotation(rotation);
         }
     }
-    _shouldUseNativeDataType() {
-        const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-        return useNorm16Texture || preferSizeOverAccuracy;
-    }
     _getCorners(bounds) {
         return [
             [bounds[0], bounds[2], bounds[4]],
@@ -928,5 +934,8 @@ class Viewport {
         const radius = Math.sqrt(w1 + w2 + w3 || 1) * 0.5;
         return radius;
     }
+    setDataIds(_imageIds, _options) {
+        throw new Error('Unsupported operatoin setDataIds');
+    }
 }
 export default Viewport;

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

@@ -1,13 +1,15 @@
-import { BlendModes, OrientationAxis } from '../enums';
+import { mat4 } from 'gl-matrix';
+import type { BlendModes } from '../enums';
+import { OrientationAxis } from '../enums';
 import type { IVolumeInput, OrientationVectors, Point3, ViewReference, ViewReferenceSpecifier } from '../types';
 import type { ViewportInput } from '../types/IViewport';
 import BaseVolumeViewport from './BaseVolumeViewport';
 declare class VolumeViewport extends BaseVolumeViewport {
     private _useAcquisitionPlaneForViewPlane;
     constructor(props: ViewportInput);
-    setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     getNumberOfSlices: () => number;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
@@ -17,20 +19,30 @@ declare class VolumeViewport extends BaseVolumeViewport {
     resetSlabThickness(): void;
     getCurrentImageIdIndex: (volumeId?: string) => number;
     getSliceIndex: () => number;
+    getSliceViewInfo(): {
+        sliceIndex: number;
+        slicePlane: number;
+        width: number;
+        height: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    getCurrentSlicePixelData(): import("../types").PixelDataTypedArray;
     getCurrentImageId: () => string | undefined;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     resetProperties(volumeId?: string): void;
     private _resetProperties;
-    getSlicesClippingPlanes(): Array<{
+    private setCameraClippingRange;
+    getSlicesClippingPlanes(): {
         sliceIndex: number;
-        planes: Array<{
+        planes: {
             normal: Point3;
             origin: Point3;
-        }>;
-    }>;
-    getSlicePlaneCoordinates: () => Array<{
+        }[];
+    }[];
+    getSlicePlaneCoordinates: () => {
         sliceIndex: number;
         point: Point3;
-    }>;
+    }[];
 }
 export default VolumeViewport;