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

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,9 +8,19 @@ import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import { mat4, vec2, vec3 } from 'gl-matrix';
 import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
-import { actorIsA, colormap as colormapUtils, createSigmoidRGBTransferFunction, imageIdToURI, imageRetrieveMetadataProvider, invertRgbTransferFunction, isEqual, isImageActor, triggerEvent, updateVTKImageDataWithCornerstoneImage, windowLevel as windowLevelUtil, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import * as colormapUtils from '../utilities/colormap';
+import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
+import * as windowLevelUtil from '../utilities/windowLevel';
+import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
+import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
+import { updateVTKImageDataWithCornerstoneImage } from '../utilities/updateVTKImageDataWithCornerstoneImage';
+import triggerEvent from '../utilities/triggerEvent';
+import { isEqual } from '../utilities/isEqual';
+import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
+import imageRetrieveMetadataProvider from '../utilities/imageRetrieveMetadataProvider';
+import imageIdToURI from '../utilities/imageIdToURI';
 import Viewport from './Viewport';
-import { getColormap } from './helpers/cpuFallback/colors/index';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
 import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
@@ -20,15 +30,12 @@ import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import resize from './helpers/cpuFallback/rendering/resize';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { getConfiguration, getShouldUseCPURendering } from '../init';
 import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
-import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
-import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { findMatchingColormap } from '../utilities/colormap';
 const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
@@ -41,7 +48,6 @@ class StackViewport extends Viewport {
         this.initialTransferFunctionNodes = null;
         this.stackInvalidated = false;
         this._publishCalibratedEvent = false;
-        this.useNativeDataType = false;
         this.updateRenderingPipeline = () => {
             this._configureRenderingPipeline();
         };
@@ -66,7 +72,7 @@ class StackViewport extends Viewport {
             if (preferSizeOverAccuracy) {
                 mapper.setPreferSizeOverAccuracy(true);
             }
-            if (imageData.getPointData().getNumberOfComponents() > 1) {
+            if (imageData.getPointData().getScalars().getNumberOfComponents() > 1) {
                 actor.getProperty().setIndependentComponents(false);
             }
             return actor;
@@ -115,9 +121,12 @@ class StackViewport extends Viewport {
         };
         this.setRotation = (rotation) => {
             const previousCamera = this.getCamera();
-            this.useCPURendering
-                ? this.setRotationCPU(rotation)
-                : this.setRotationGPU(rotation);
+            if (this.useCPURendering) {
+                this.setRotationCPU(rotation);
+            }
+            else {
+                this.setRotationGPU(rotation);
+            }
             if (this._suppressCameraModifiedEvents) {
                 return;
             }
@@ -159,11 +168,11 @@ class StackViewport extends Viewport {
             const iVector = direction.slice(0, 3);
             const jVector = direction.slice(3, 6);
             const diff = vec3.subtract(vec3.create(), worldPos, origin);
-            const worldPoint = [
+            const indexPoint = [
                 vec3.dot(diff, iVector) / spacing[0],
                 vec3.dot(diff, jVector) / spacing[1],
             ];
-            const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, worldPoint);
+            const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, indexPoint);
             return canvasPoint;
         };
         this.canvasToWorldGPU = (canvasPos) => {
@@ -365,9 +374,8 @@ class StackViewport extends Viewport {
         this.scaling = {};
         this.modality = null;
         this.useCPURendering = getShouldUseCPURendering();
-        this.useNativeDataType = this._shouldUseNativeDataType();
         this._configureRenderingPipeline();
-        this.useCPURendering
+        const result = this.useCPURendering
             ? this._resetCPUFallbackElement()
             : this._resetGPUViewport();
         this.imageIds = [];
@@ -385,7 +393,6 @@ class StackViewport extends Viewport {
         return getShouldUseCPURendering();
     }
     _configureRenderingPipeline(value) {
-        this.useNativeDataType = this._shouldUseNativeDataType();
         this.useCPURendering = value ?? getShouldUseCPURendering();
         for (const key in this.renderingPipelineFunctions) {
             if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
@@ -393,7 +400,7 @@ class StackViewport extends Viewport {
                 this[key] = this.useCPURendering ? functions.cpu : functions.gpu;
             }
         }
-        this.useCPURendering
+        const result = this.useCPURendering
             ? this._resetCPUFallbackElement()
             : this._resetGPUViewport();
     }
@@ -438,7 +445,9 @@ class StackViewport extends Viewport {
             spacing: vtkImageData.getSpacing(),
             origin: vtkImageData.getOrigin(),
             direction: vtkImageData.getDirection(),
-            scalarData: vtkImageData.getPointData().getScalars().getData(),
+            get scalarData() {
+                return this.csImage.voxelManager.getScalarData();
+            },
             imageData: actor.getMapper().getInputData(),
             metadata: {
                 Modality: this.modality,
@@ -450,6 +459,7 @@ class StackViewport extends Viewport {
             preScale: {
                 ...this.csImage.preScale,
             },
+            voxelManager: this.csImage.voxelManager,
         };
     }
     getImageDataCPU() {
@@ -489,6 +499,7 @@ class StackViewport extends Viewport {
             preScale: {
                 ...this.csImage.preScale,
             },
+            voxelManager: this.csImage.voxelManager,
         };
     }
     buildMetadata(image) {
@@ -623,7 +634,7 @@ class StackViewport extends Viewport {
             return acc;
         }, []);
         const defaultActor = this.getDefaultActor();
-        const matchedColormap = findMatchingColormap(RGBPoints, defaultActor.actor);
+        const matchedColormap = colormapUtils.findMatchingColormap(RGBPoints, defaultActor.actor);
         this.setColormap(matchedColormap);
     }
     resetToDefaultProperties() {
@@ -981,7 +992,7 @@ class StackViewport extends Viewport {
     _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
         let numberOfComponents = 1;
         if (photometricInterpretation === 'RGB' ||
-            photometricInterpretation.indexOf('YBR') !== -1 ||
+            photometricInterpretation.includes('YBR') ||
             photometricInterpretation === 'PALETTE COLOR') {
             numberOfComponents = 3;
         }
@@ -1010,11 +1021,11 @@ class StackViewport extends Viewport {
         const yVoxels = image.rows;
         const zSpacing = EPSILON;
         const zVoxels = 1;
-        const numComps = image.numComps ||
+        const numberOfComponents = image.numberOfComponents ||
             this._getNumCompsFromPhotometricInterpretation(imagePixelModule.photometricInterpretation);
         return {
             bitsAllocated: imagePixelModule.bitsAllocated,
-            numComps,
+            numberOfComponents,
             origin,
             direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
             dimensions: [xVoxels, yVoxels, zVoxels],
@@ -1037,7 +1048,7 @@ class StackViewport extends Viewport {
         let { rowCosines, columnCosines } = imagePlaneModule;
         rowCosines ||= [1, 0, 0];
         columnCosines ||= [0, 1, 0];
-        const viewPlaneNormal = (vec3.cross([0, 0, 0], columnCosines, rowCosines));
+        const viewPlaneNormal = vec3.cross([0, 0, 0], columnCosines, rowCosines);
         return {
             FrameOfReferenceUID,
             viewPlaneNormal,
@@ -1058,11 +1069,11 @@ class StackViewport extends Viewport {
             viewUp: [viewUp[0], viewUp[1], viewUp[2]],
         };
     }
-    createVTKImageData({ origin, direction, dimensions, spacing, numComps, pixelArray, }) {
+    createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
         const values = new pixelArray.constructor(pixelArray.length);
         const scalarArray = vtkDataArray.newInstance({
             name: 'Pixels',
-            numberOfComponents: numComps,
+            numberOfComponents: numberOfComponents,
             values: values,
         });
         const imageData = vtkImageData.newInstance();
@@ -1073,15 +1084,20 @@ class StackViewport extends Viewport {
         imageData.getPointData().setScalars(scalarArray);
         return imageData;
     }
-    _createVTKImageData({ origin, direction, dimensions, spacing, numComps, pixelArray, }) {
-        this._imageData = this.createVTKImageData({
-            origin,
-            direction,
-            dimensions,
-            spacing,
-            numComps,
-            pixelArray,
-        });
+    _createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
+        try {
+            this._imageData = this.createVTKImageData({
+                origin,
+                direction,
+                dimensions,
+                spacing,
+                numberOfComponents,
+                pixelArray,
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
     }
     async setStack(imageIds, currentImageIdIndex = 0) {
         this._throwIfDestroyed();
@@ -1142,8 +1158,7 @@ class StackViewport extends Viewport {
             yVoxels === image.rows &&
             isEqual(imagePlaneModule.rowCosines, rowCosines) &&
             isEqual(imagePlaneModule.columnCosines, columnCosines) &&
-            (!this.useNativeDataType ||
-                dataType === image.getPixelData().constructor.name));
+            dataType === image.voxelManager.getScalarData().constructor.name);
     }
     _updateVTKImageDataFromCornerstoneImage(image) {
         const imagePlaneModule = this._getImagePlaneModule(image.imageId);
@@ -1165,7 +1180,7 @@ class StackViewport extends Viewport {
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
-                const pixelData = image.getPixelData();
+                const pixelData = image.voxelManager.getScalarData();
                 const preScale = image.preScale;
                 const scalingParams = preScale?.scalingParameters;
                 const scaledWithNonIntegers = (preScale?.scaled && scalingParams?.rescaleIntercept % 1 !== 0) ||
@@ -1290,17 +1305,12 @@ class StackViewport extends Viewport {
     getLoaderImageOptions(imageId) {
         const imageIdIndex = this.imageIds.indexOf(imageId);
         const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
-        const additionalDetails = { imageId, imageIdIndex };
         const options = {
-            targetBuffer: {
-                type: this.useNativeDataType ? undefined : 'Float32Array',
-            },
             useRGBA: false,
             transferSyntaxUID,
-            useNativeDataType: this.useNativeDataType,
             priority: 5,
             requestType: RequestType.Interaction,
-            additionalDetails,
+            additionalDetails: { imageId, imageIdIndex },
         };
         return options;
     }
@@ -1346,7 +1356,7 @@ class StackViewport extends Viewport {
         this._cpuFallbackEnabledElement.metadata = {
             ...metadata,
         };
-        this.cpuImagePixelData = image.getPixelData();
+        this.cpuImagePixelData = image.voxelManager.getScalarData();
         const viewportSettingToUse = Object.assign({}, viewport, this._cpuFallbackEnabledElement.viewport);
         this._cpuFallbackEnabledElement.viewport = this.stackInvalidated
             ? viewport
@@ -1355,19 +1365,22 @@ class StackViewport extends Viewport {
         this.cpuRenderingInvalidated = true;
         this._cpuFallbackEnabledElement.transform = calculateTransform(this._cpuFallbackEnabledElement);
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     addImages(stackInputs) {
         const actors = this.getActors();
         stackInputs.forEach((stackInput) => {
             const { imageId } = stackInput;
             const image = cache.getImage(imageId);
-            const { origin, dimensions, direction, spacing, numComps } = this.getImageDataMetadata(image);
+            const { origin, dimensions, direction, spacing, numberOfComponents } = this.getImageDataMetadata(image);
             const imagedata = this.createVTKImageData({
                 origin,
                 dimensions,
                 direction,
                 spacing,
-                numComps,
-                pixelArray: image.getPixelData(),
+                numberOfComponents,
+                pixelArray: image.voxelManager.getScalarData(),
             });
             const imageActor = this.createActorMapper(imagedata);
             if (imageActor) {
@@ -1405,14 +1418,14 @@ class StackViewport extends Viewport {
             this.stackActorReInitialized = false;
             return;
         }
-        const { origin, direction, dimensions, spacing, numComps, imagePixelModule, } = this.getImageDataMetadata(image);
-        const pixelArray = image.getPixelData();
+        const { origin, direction, dimensions, spacing, numberOfComponents, imagePixelModule, } = this.getImageDataMetadata(image);
+        const pixelArray = image.voxelManager.getScalarData();
         this._createVTKImageData({
             origin,
             direction,
             dimensions,
             spacing,
-            numComps,
+            numberOfComponents,
             pixelArray,
         });
         this._updateVTKImageDataFromCornerstoneImage(image);
@@ -1464,7 +1477,7 @@ class StackViewport extends Viewport {
         if (this.modality !== 'PT' || !this.csImage.isPreScaled) {
             return false;
         }
-        if (!this.csImage.preScale?.scalingParameters?.suvbw) {
+        if (!this.csImage.preScale?.scalingParameters.suvbw) {
             return false;
         }
         return true;
@@ -1626,18 +1639,28 @@ class StackViewport extends Viewport {
         return this._getVOIRangeFromWindowLevel(windowWidth, windowCenter);
     }
     _getValidVOILUTFunction(voiLUTFunction) {
-        if (Object.values(VOILUTFunctionType).indexOf(voiLUTFunction) === -1) {
-            voiLUTFunction = VOILUTFunctionType.LINEAR;
+        if (!Object.values(VOILUTFunctionType).includes(voiLUTFunction)) {
+            return VOILUTFunctionType.LINEAR;
         }
         return voiLUTFunction;
     }
+    getSliceInfo() {
+        const sliceIndex = this.getSliceIndex();
+        const { dimensions } = this.getImageData();
+        return {
+            width: dimensions[0],
+            height: dimensions[1],
+            sliceIndex,
+            slicePlane: 2,
+        };
+    }
     isReferenceViewable(viewRef, options = {}) {
         if (!super.isReferenceViewable(viewRef, options)) {
             return false;
         }
         const { referencedImageId, sliceIndex } = viewRef;
         if (viewRef.volumeId && !referencedImageId) {
-            return options.asVolume === true;
+            return options.asVolume;
         }
         let testIndex = this.getCurrentImageIdIndex();
         const currentImageId = this.imageIds[testIndex];
@@ -1715,16 +1738,16 @@ class StackViewport extends Viewport {
         if (!viewRef) {
             return;
         }
-        const { referencedImageId, sliceIndex, volumeId } = viewRef;
+        const { referencedImageId, sliceIndex } = viewRef;
         if (typeof sliceIndex === 'number' &&
             referencedImageId &&
             referencedImageId === this.imageIds[sliceIndex]) {
-            this.setImageIdIndex(sliceIndex);
+            this.scroll(sliceIndex - this.targetImageIdIndex);
         }
         else {
             const foundIndex = this.imageIds.indexOf(referencedImageId);
             if (foundIndex !== -1) {
-                this.setImageIdIndex(foundIndex);
+                this.scroll(foundIndex - this.targetImageIdIndex);
             }
             else {
                 throw new Error('Unsupported - referenced image id not found');
@@ -1756,7 +1779,7 @@ class StackViewport extends Viewport {
     }
     setColormapCPU(colormapData) {
         this.colormap = colormapData;
-        const colormap = getColormap(colormapData.name, colormapData);
+        const colormap = colormapUtils.getColormap(colormapData.name);
         this._cpuFallbackEnabledElement.viewport.colormap = colormap;
         this._cpuFallbackEnabledElement.renderingTools = {};
         this.fillWithBackgroundColor();

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

@@ -1,5 +1,6 @@
+import type { mat4 } from 'gl-matrix';
 import { VideoEnums as VideoViewportEnum } from '../enums';
-import type { IVideoViewport, VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions } from '../types';
+import type { IVideoViewport, VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import Viewport from './Viewport';
 import CanvasActor from './CanvasActor';
@@ -39,7 +40,7 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     private elementDisabledHandler;
     getImageDataMetadata(image: IImage | string): {
         bitsAllocated: number;
-        numComps: number;
+        numberOfComponents: number;
         origin: any;
         rows: any;
         columns: any;
@@ -50,16 +51,25 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
         numVoxels: number;
         imagePlaneModule: any;
     };
+    setDataIds(imageIds: string[], options?: ImageSetOptions): void;
     setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
     setVideoURL(videoURL: string): Promise<unknown>;
     getImageIds(): string[];
     togglePlayPause(): boolean;
     play(): Promise<void>;
-    pause(): Promise<void>;
+    pause(): void;
     scroll(delta?: number): Promise<void>;
     start(): Promise<void>;
     end(): Promise<void>;
     setTime(timeInSeconds: number): Promise<void>;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
     setFrameNumber(frame: number): Promise<void>;
     setFrameRange(frameRange: number[]): void;
     getFrameRange(): [number, number];
@@ -69,30 +79,9 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     getProperties: () => VideoViewportProperties;
     resetProperties(): void;
     protected getScalarData(): CanvasScalarData;
-    getImageData(): {
-        dimensions: any;
-        spacing: any;
-        origin: any;
-        direction: any;
-        metadata: {
-            Modality: any;
-        };
-        getScalarData: () => CanvasScalarData;
-        imageData: {
-            getDirection: () => any;
-            getDimensions: () => any;
-            getRange: () => number[];
-            getScalarData: () => CanvasScalarData;
-            getSpacing: () => any;
-            worldToIndex: (point: Point3) => number[];
-            indexToWorld: (point: Point2, destPoint?: Point3) => Point3;
-        };
-        hasPixelSpacing: boolean;
-        calibration: import("../types").IImageCalibration;
-        preScale: {
-            scaled: boolean;
-        };
-    };
+    getImageData(): IImageData | CPUIImageData;
+    getMiddleSliceData: () => never;
+    useCustomRenderingPipeline: boolean;
     hasImageURI(imageURI: string): boolean;
     setVOI(voiRange: VOIRange): void;
     setWindowLevel(windowWidth?: number, windowCenter?: number): void;
@@ -102,6 +91,7 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     getCurrentImageId(): string;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    setViewReference(viewRef: ViewReference): void;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     getFrameNumber(): number;
     getCurrentImageIdIndex(): number;
@@ -109,6 +99,7 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     getCamera(): ICamera;
     resetCamera: () => boolean;
     getNumberOfSlices: () => number;
+    getFrameRate(): number;
     getFrameOfReferenceUID: () => string;
     resize: () => void;
     canvasToWorld: (canvasPos: Point2, destPos?: Point3) => Point3;
@@ -123,7 +114,7 @@ declare class VideoViewport extends Viewport implements IVideoViewport {
     customRenderViewportToCanvas: () => void;
     protected getTransform(): Transform;
     updateCameraClippingPlanesAndRange(): void;
-    addImages(stackInputs: Array<any>): void;
+    addImages(stackInputs: IStackInput[]): void;
     protected createActorMapper(image: any): CanvasActor;
     private renderFrame;
     private renderWhilstPlaying;