@cornerstonejs/core 0.1.1

package/dist/esm/RenderingEngine/StackViewport.js

@@ -0,0 +1,1142 @@
+import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
+import vtkImageData from 'vtk.js/Sources/Common/DataModel/ImageData';
+import vtkVolume from 'vtk.js/Sources/Rendering/Core/Volume';
+import vtkVolumeMapper from 'vtk.js/Sources/Rendering/Core/VolumeMapper';
+import _cloneDeep from 'lodash.clonedeep';
+import vtkCamera from 'vtk.js/Sources/Rendering/Core/Camera';
+import { vec2, vec3 } from 'gl-matrix';
+import metaData from '../metaData';
+import Viewport from './Viewport';
+import eventTarget from '../eventTarget';
+import Events from '../enums/Events';
+import { triggerEvent, isEqual, invertRgbTransferFunction, windowLevel as windowLevelUtil, } from '../utilities';
+import drawImageSync from './helpers/cpuFallback/drawImageSync';
+import { getColormap } from './helpers/cpuFallback/colors/index';
+import { loadAndCacheImage } from '../imageLoader';
+import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
+import InterpolationType from '../enums/InterpolationType';
+import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
+import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
+import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
+import calculateTransform from './helpers/cpuFallback/rendering/calculateTransform';
+import resize from './helpers/cpuFallback/rendering/resize';
+import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
+import { Transform } from './helpers/cpuFallback/rendering/transform';
+import { getShouldUseCPURendering } from '../init';
+import RequestType from '../enums/RequestType';
+const EPSILON = 1;
+class StackViewport extends Viewport {
+    constructor(props) {
+        super(props);
+        this.invert = false;
+        this.rotation = 0;
+        this.stackInvalidated = false;
+        this.shouldFlip = false;
+        this.voiApplied = false;
+        this.rotationCache = 0;
+        this._publishCalibratedEvent = false;
+        this.resize = () => {
+            if (this.useCPURendering) {
+                this._resizeCPU();
+            }
+        };
+        this._resizeCPU = () => {
+            if (this._cpuFallbackEnabledElement.viewport) {
+                resize(this._cpuFallbackEnabledElement);
+            }
+        };
+        this.getFrameOfReferenceUID = () => {
+            const imageId = this.getCurrentImageId();
+            if (!imageId) {
+                return;
+            }
+            const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+            if (!imagePlaneModule) {
+                return;
+            }
+            return imagePlaneModule.frameOfReferenceUID;
+        };
+        this.createActorMapper = (imageData) => {
+            const mapper = vtkVolumeMapper.newInstance();
+            mapper.setInputData(imageData);
+            const actor = vtkVolume.newInstance();
+            actor.setMapper(mapper);
+            const [xSize, ySize, zSize] = imageData.getDimensions();
+            const [xSpacing, ySpacing, zSpacing] = imageData.getSpacing();
+            const vSize = vec3.length([
+                xSize * xSpacing,
+                ySize * ySpacing,
+                zSize * zSpacing,
+            ]);
+            mapper.setSampleDistance(vSize / mapper.getMaximumSamplesPerRay());
+            if (imageData.getPointData().getNumberOfComponents() > 1) {
+                actor.getProperty().setIndependentComponents(false);
+            }
+            return actor;
+        };
+        this.getProperties = () => {
+            return {
+                voiRange: this.voiRange,
+                rotation: this.rotationCache,
+                interpolationType: this.interpolationType,
+                invert: this.invert,
+                flipHorizontal: this.flipHorizontal,
+                flipVertical: this.flipVertical,
+            };
+        };
+        this.canvasToWorld = (canvasPos) => {
+            if (this.useCPURendering) {
+                return this.canvasToWorldCPU(canvasPos);
+            }
+            return this.canvasToWorldGPU(canvasPos);
+        };
+        this.worldToCanvas = (worldPos) => {
+            if (this.useCPURendering) {
+                return this.worldToCanvasCPU(worldPos);
+            }
+            return this.worldToCanvasGPU(worldPos);
+        };
+        this.canvasToWorldCPU = (canvasPos) => {
+            if (!this._cpuFallbackEnabledElement.image) {
+                return;
+            }
+            const [px, py] = canvasToPixel(this._cpuFallbackEnabledElement, canvasPos);
+            const { origin, spacing, direction } = this.getImageData();
+            const worldPos = vec3.fromValues(0, 0, 0);
+            const iVector = direction.slice(0, 3);
+            const jVector = direction.slice(3, 6);
+            vec3.scaleAndAdd(worldPos, origin, iVector, px * spacing[0]);
+            vec3.scaleAndAdd(worldPos, worldPos, jVector, py * spacing[1]);
+            return worldPos;
+        };
+        this.worldToCanvasCPU = (worldPos) => {
+            const { spacing, direction, origin } = this.getImageData();
+            const iVector = direction.slice(0, 3);
+            const jVector = direction.slice(3, 6);
+            const diff = vec3.subtract(vec3.create(), worldPos, origin);
+            const worldPoint = [
+                vec3.dot(diff, iVector) / spacing[0],
+                vec3.dot(diff, jVector) / spacing[1],
+            ];
+            const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, worldPoint);
+            return canvasPoint;
+        };
+        this.canvasToWorldGPU = (canvasPos) => {
+            const renderer = this.getRenderer();
+            const offscreenMultiRenderWindow = this.getRenderingEngine().offscreenMultiRenderWindow;
+            const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
+            const size = openGLRenderWindow.getSize();
+            const displayCoord = [canvasPos[0] + this.sx, canvasPos[1] + this.sy];
+            displayCoord[1] = size[1] - displayCoord[1];
+            let worldCoord = openGLRenderWindow.displayToWorld(displayCoord[0], displayCoord[1], 0, renderer);
+            worldCoord = this.applyFlipTx(worldCoord);
+            return worldCoord;
+        };
+        this.worldToCanvasGPU = (worldPos) => {
+            const renderer = this.getRenderer();
+            const offscreenMultiRenderWindow = this.getRenderingEngine().offscreenMultiRenderWindow;
+            const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
+            const size = openGLRenderWindow.getSize();
+            const displayCoord = openGLRenderWindow.worldToDisplay(...this.applyFlipTx(worldPos), renderer);
+            displayCoord[1] = size[1] - displayCoord[1];
+            const canvasCoord = [
+                displayCoord[0] - this.sx,
+                displayCoord[1] - this.sy,
+            ];
+            return canvasCoord;
+        };
+        this.getCurrentImageIdIndex = () => {
+            return this.currentImageIdIndex;
+        };
+        this.getImageIds = () => {
+            return this.imageIds;
+        };
+        this.getCurrentImageId = () => {
+            return this.imageIds[this.currentImageIdIndex];
+        };
+        this.customRenderViewportToCanvas = () => {
+            if (!this.useCPURendering) {
+                throw new Error('Custom cpu rendering pipeline should only be hit in CPU rendering mode');
+            }
+            if (this._cpuFallbackEnabledElement.image) {
+                drawImageSync(this._cpuFallbackEnabledElement, this.cpuRenderingInvalidated);
+                this.cpuRenderingInvalidated = false;
+            }
+            else {
+                this.fillWithBackgroundColor();
+            }
+            return {
+                canvas: this.canvas,
+                element: this.element,
+                viewportUID: this.uid,
+                renderingEngineUID: this.renderingEngineUID,
+            };
+        };
+        this.scaling = {};
+        this.modality = null;
+        this.useCPURendering = getShouldUseCPURendering();
+        if (this.useCPURendering) {
+            this._cpuFallbackEnabledElement = {
+                canvas: this.canvas,
+                renderingTools: {},
+                transform: new Transform(),
+                viewport: {},
+            };
+        }
+        else {
+            const renderer = this.getRenderer();
+            const camera = vtkCamera.newInstance();
+            renderer.setActiveCamera(camera);
+            const sliceNormal = [0, 0, -1];
+            const viewUp = [0, -1, 0];
+            camera.setDirectionOfProjection(-sliceNormal[0], -sliceNormal[1], -sliceNormal[2]);
+            camera.setViewUp(...viewUp);
+            camera.setParallelProjection(true);
+            camera.setFreezeFocalPoint(true);
+        }
+        this.imageIds = [];
+        this.currentImageIdIndex = 0;
+        this.panCache = [0, 0, 0];
+        this.cameraPosOnRender = [0, 0, 0];
+        this.resetCamera();
+    }
+    static get useCustomRenderingPipeline() {
+        return getShouldUseCPURendering();
+    }
+    getImageData() {
+        if (this.useCPURendering) {
+            return this.getImageDataCPU();
+        }
+        else {
+            return this.getImageDataGPU();
+        }
+    }
+    getImageDataGPU() {
+        const actor = this.getDefaultActor();
+        if (!actor) {
+            return;
+        }
+        const { volumeActor } = actor;
+        const vtkImageData = volumeActor.getMapper().getInputData();
+        return {
+            dimensions: vtkImageData.getDimensions(),
+            spacing: vtkImageData.getSpacing(),
+            origin: vtkImageData.getOrigin(),
+            direction: vtkImageData.getDirection(),
+            scalarData: vtkImageData.getPointData().getScalars().getData(),
+            imageData: volumeActor.getMapper().getInputData(),
+            metadata: { Modality: this.modality },
+            scaling: this.scaling,
+        };
+    }
+    getImageDataCPU() {
+        const { metadata } = this._cpuFallbackEnabledElement;
+        const spacing = metadata.spacing;
+        return {
+            dimensions: metadata.dimensions,
+            spacing,
+            origin: metadata.origin,
+            direction: metadata.direction,
+            metadata: { Modality: this.modality },
+            scaling: this.scaling,
+            imageData: {
+                getDirection: () => metadata.direction,
+                getDimensions: () => metadata.dimensions,
+                getScalarData: () => this.cpuImagePixelData,
+                getSpacing: () => spacing,
+                worldToIndex: (point) => {
+                    const canvasPoint = this.worldToCanvasCPU(point);
+                    const pixelCoord = canvasToPixel(this._cpuFallbackEnabledElement, canvasPoint);
+                    return [pixelCoord[0], pixelCoord[1], 0];
+                },
+                indexToWorld: (point) => {
+                    const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, [
+                        point[0],
+                        point[1],
+                    ]);
+                    return this.canvasToWorldCPU(canvasPoint);
+                },
+            },
+            scalarData: this.cpuImagePixelData,
+        };
+    }
+    buildMetadata(imageId) {
+        const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId);
+        const voiLutModule = metaData.get('voiLutModule', imageId);
+        let windowWidth, windowCenter;
+        if (voiLutModule) {
+            ;
+            ({ windowWidth, windowCenter } = voiLutModule);
+            if (Array.isArray(windowWidth)) {
+                windowWidth = windowWidth[0];
+            }
+            if (Array.isArray(windowCenter)) {
+                windowCenter = windowCenter[0];
+            }
+        }
+        const { modality } = metaData.get('generalSeriesModule', imageId);
+        const imageIdScalingFactor = metaData.get('scalingModule', imageId);
+        if (modality === 'PT' && imageIdScalingFactor) {
+            this._addScalingToViewport(imageIdScalingFactor);
+        }
+        this.modality = modality;
+        let imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+        if (!this.useCPURendering) {
+            imagePlaneModule = this.calibrateIfNecessary(imageId, imagePlaneModule);
+        }
+        return {
+            imagePlaneModule,
+            imagePixelModule: {
+                bitsAllocated,
+                bitsStored,
+                samplesPerPixel,
+                highBit,
+                photometricInterpretation,
+                pixelRepresentation,
+                windowWidth,
+                windowCenter,
+                modality,
+            },
+        };
+    }
+    calibrateIfNecessary(imageId, imagePlaneModule) {
+        const calibratedPixelSpacing = metaData.get('calibratedPixelSpacing', imageId);
+        if (!calibratedPixelSpacing) {
+            return imagePlaneModule;
+        }
+        const [calibratedRowSpacing, calibratedColumnSpacing] = calibratedPixelSpacing;
+        if (imagePlaneModule.rowPixelSpacing === calibratedRowSpacing &&
+            imagePlaneModule.columnPixelSpacing === calibratedColumnSpacing) {
+            return imagePlaneModule;
+        }
+        const imageDataMetadata = this.getImageData();
+        if (!imageDataMetadata &&
+            imagePlaneModule.rowPixelSpacing === calibratedRowSpacing &&
+            imagePlaneModule.columnPixelSpacing === calibratedColumnSpacing) {
+            return imagePlaneModule;
+        }
+        if (!imageDataMetadata &&
+            (imagePlaneModule.rowPixelSpacing !== calibratedRowSpacing ||
+                imagePlaneModule.columnPixelSpacing !== calibratedColumnSpacing)) {
+            this._publishCalibratedEvent = true;
+            this._calibrationEvent = {
+                rowScale: calibratedRowSpacing / imagePlaneModule.rowPixelSpacing,
+                columnScale: calibratedColumnSpacing / imagePlaneModule.columnPixelSpacing,
+            };
+            imagePlaneModule.rowPixelSpacing = calibratedRowSpacing;
+            imagePlaneModule.columnPixelSpacing = calibratedColumnSpacing;
+            return imagePlaneModule;
+        }
+        const { imageData } = imageDataMetadata;
+        const [columnPixelSpacing, rowPixelSpacing] = imageData.getSpacing();
+        imagePlaneModule.rowPixelSpacing = calibratedRowSpacing;
+        imagePlaneModule.columnPixelSpacing = calibratedColumnSpacing;
+        if (rowPixelSpacing === calibratedRowSpacing &&
+            columnPixelSpacing === calibratedPixelSpacing) {
+            return imagePlaneModule;
+        }
+        this._publishCalibratedEvent = true;
+        this._calibrationEvent = {
+            rowScale: calibratedRowSpacing / rowPixelSpacing,
+            columnScale: calibratedColumnSpacing / columnPixelSpacing,
+        };
+        return imagePlaneModule;
+    }
+    setProperties({ voiRange, invert, interpolationType, rotation, flipHorizontal, flipVertical, } = {}) {
+        if (typeof voiRange !== 'undefined' || !this.voiApplied) {
+            this.setVOI(voiRange);
+        }
+        if (typeof invert !== 'undefined') {
+            this.setInvertColor(invert);
+        }
+        if (typeof interpolationType !== 'undefined') {
+            this.setInterpolationType(interpolationType);
+        }
+        if (typeof rotation !== 'undefined') {
+            if (this.rotationCache !== rotation) {
+                this.setRotation(this.rotationCache, rotation);
+            }
+        }
+        if (typeof flipHorizontal !== 'undefined' ||
+            typeof flipVertical !== 'undefined') {
+            this.setFlipDirection({ flipHorizontal, flipVertical });
+        }
+    }
+    resetProperties() {
+        this.cpuRenderingInvalidated = true;
+        this.fillWithBackgroundColor();
+        if (this.useCPURendering) {
+            this._cpuFallbackEnabledElement.renderingTools = {};
+        }
+        this._resetProperties();
+        this.render();
+    }
+    getCamera() {
+        if (this.useCPURendering) {
+            return this.getCameraCPU();
+        }
+        else {
+            return super.getCamera();
+        }
+    }
+    setCamera(cameraInterface) {
+        if (this.useCPURendering) {
+            this.setCameraCPU(cameraInterface);
+        }
+        else {
+            super.setCamera(cameraInterface);
+        }
+    }
+    _resetProperties() {
+        this.voiApplied = false;
+        this.setProperties({
+            voiRange: undefined,
+            rotation: 0,
+            interpolationType: InterpolationType.LINEAR,
+            invert: false,
+            flipHorizontal: false,
+            flipVertical: false,
+        });
+    }
+    _setPropertiesFromCache() {
+        this.setProperties({
+            voiRange: this.voiRange,
+            rotation: this.rotation,
+            interpolationType: this.interpolationType,
+            invert: this.invert,
+            flipHorizontal: this.flipHorizontal,
+            flipVertical: this.flipVertical,
+        });
+    }
+    getCameraCPU() {
+        const { metadata, viewport } = this._cpuFallbackEnabledElement;
+        const { direction } = metadata;
+        const viewPlaneNormal = direction.slice(6, 9).map((x) => -x);
+        const viewUp = direction.slice(3, 6).map((x) => -x);
+        return {
+            parallelProjection: true,
+            focalPoint: [0, 0, 0],
+            position: [0, 0, 0],
+            parallelScale: viewport.scale,
+            viewPlaneNormal: [
+                viewPlaneNormal[0],
+                viewPlaneNormal[1],
+                viewPlaneNormal[2],
+            ],
+            viewUp: [viewUp[0], viewUp[1], viewUp[2]],
+        };
+    }
+    setCameraCPU(cameraInterface) {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        const previousCamera = this.getCameraCPU();
+        const { focalPoint, viewUp, parallelScale } = cameraInterface;
+        if (focalPoint) {
+            const focalPointCanvas = this.worldToCanvasCPU(cameraInterface.focalPoint);
+            const previousFocalPointCanvas = this.worldToCanvasCPU(previousCamera.focalPoint);
+            const deltaCanvas = vec2.create();
+            vec2.subtract(deltaCanvas, vec2.fromValues(previousFocalPointCanvas[0], previousFocalPointCanvas[1]), vec2.fromValues(focalPointCanvas[0], focalPointCanvas[1]));
+            viewport.translation.x += deltaCanvas[0] / previousCamera.parallelScale;
+            viewport.translation.y += deltaCanvas[1] / previousCamera.parallelScale;
+        }
+        if (parallelScale && previousCamera.parallelScale !== parallelScale) {
+            const diff = previousCamera.parallelScale - parallelScale;
+            viewport.scale += diff;
+        }
+        const updatedCamera = {
+            ...previousCamera,
+            focalPoint,
+            viewUp,
+            parallelScale,
+        };
+        const eventDetail = {
+            previousCamera,
+            camera: updatedCamera,
+            element: this.element,
+            viewportUID: this.uid,
+            renderingEngineUID: this.renderingEngineUID,
+        };
+        triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
+    }
+    setFlipDirection(flipDirection) {
+        if (this.useCPURendering) {
+            this.setFlipCPU(flipDirection);
+        }
+        else {
+            super.flip(flipDirection);
+        }
+        this.shouldFlip = false;
+    }
+    setFlipCPU({ flipHorizontal, flipVertical }) {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        viewport.hflip = flipHorizontal;
+        this.flipHorizontal = viewport.hflip;
+        viewport.vflip = flipVertical;
+        this.flipVertical = viewport.vflip;
+    }
+    setVOI(voiRange) {
+        if (this.useCPURendering) {
+            this.setVOICPU(voiRange);
+            return;
+        }
+        this.setVOIGPU(voiRange);
+    }
+    setRotation(rotationCache, rotation) {
+        if (this.useCPURendering) {
+            this.setRotationCPU(rotationCache, rotation);
+            return;
+        }
+        this.setRotationGPU(rotationCache, rotation);
+    }
+    setInterpolationType(interpolationType) {
+        if (this.useCPURendering) {
+            this.setInterpolationTypeCPU(interpolationType);
+            return;
+        }
+        this.setInterpolationTypeGPU(interpolationType);
+    }
+    setInvertColor(invert) {
+        if (this.useCPURendering) {
+            this.setInvertColorCPU(invert);
+            return;
+        }
+        this.setInvertColorGPU(invert);
+    }
+    setRotationCPU(rotationCache, rotation) {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        viewport.rotation = rotation;
+        this.rotationCache = rotation;
+        this.rotation = rotation;
+    }
+    setRotationGPU(rotationCache, rotation) {
+        this.getVtkActiveCamera().roll(rotationCache);
+        this.getVtkActiveCamera().roll(-rotation);
+        this.rotationCache = rotation;
+        this.rotation = rotation;
+    }
+    setInterpolationTypeGPU(interpolationType) {
+        const actor = this.getDefaultActor();
+        if (!actor) {
+            return;
+        }
+        const { volumeActor } = actor;
+        const volumeProperty = volumeActor.getProperty();
+        volumeProperty.setInterpolationType(interpolationType);
+        this.interpolationType = interpolationType;
+    }
+    setInterpolationTypeCPU(interpolationType) {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        if (interpolationType === InterpolationType.LINEAR) {
+            viewport.pixelReplication = false;
+        }
+        else {
+            viewport.pixelReplication = true;
+        }
+        this.interpolationType = interpolationType;
+    }
+    setInvertColorCPU(invert) {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        if (!viewport) {
+            return;
+        }
+        viewport.invert = invert;
+        this.invert = invert;
+    }
+    setInvertColorGPU(invert) {
+        const actor = this.getDefaultActor();
+        if (!actor) {
+            return;
+        }
+        const { volumeActor } = actor;
+        const tfunc = volumeActor.getProperty().getRGBTransferFunction(0);
+        if ((!this.invert && invert) || (this.invert && !invert)) {
+            invertRgbTransferFunction(tfunc);
+        }
+        this.invert = invert;
+    }
+    setVOICPU(voiRange) {
+        const { viewport, image } = this._cpuFallbackEnabledElement;
+        if (!viewport || !image) {
+            return;
+        }
+        if (typeof voiRange === 'undefined') {
+            const { windowWidth: ww, windowCenter: wc } = image;
+            const wwToUse = Array.isArray(ww) ? ww[0] : ww;
+            const wcToUse = Array.isArray(wc) ? wc[0] : wc;
+            viewport.voi = {
+                windowWidth: wwToUse,
+                windowCenter: wcToUse,
+            };
+            const { lower, upper } = windowLevelUtil.toLowHighRange(wwToUse, wcToUse);
+            this.voiRange = { lower, upper };
+        }
+        else {
+            const { lower, upper } = voiRange;
+            const { windowCenter, windowWidth } = windowLevelUtil.toWindowLevel(lower, upper);
+            if (!viewport.voi) {
+                viewport.voi = {
+                    windowWidth: 0,
+                    windowCenter: 0,
+                };
+            }
+            viewport.voi.windowWidth = windowWidth;
+            viewport.voi.windowCenter = windowCenter;
+            this.voiRange = voiRange;
+        }
+        this.voiApplied = true;
+    }
+    setVOIGPU(voiRange) {
+        const actor = this.getDefaultActor();
+        if (!actor) {
+            return;
+        }
+        const { volumeActor } = actor;
+        const tfunc = volumeActor.getProperty().getRGBTransferFunction(0);
+        if (typeof voiRange === 'undefined') {
+            const imageData = volumeActor.getMapper().getInputData();
+            const range = imageData.getPointData().getScalars().getRange();
+            tfunc.setRange(range[0], range[1]);
+            this.voiRange = { lower: range[0], upper: range[1] };
+        }
+        else {
+            const { lower, upper } = voiRange;
+            tfunc.setRange(lower, upper);
+            this.voiRange = voiRange;
+        }
+        this.voiApplied = true;
+    }
+    _addScalingToViewport(imageIdScalingFactor) {
+        if (!this.scaling.PET) {
+            const { suvbw, suvlbm, suvbsa } = imageIdScalingFactor;
+            const petScaling = {};
+            if (suvlbm) {
+                petScaling.suvbwToSuvlbm = suvlbm / suvbw;
+            }
+            if (suvbsa) {
+                petScaling.suvbwToSuvbsa = suvbsa / suvbw;
+            }
+            this.scaling.PET = petScaling;
+        }
+    }
+    _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
+        let numberOfComponents = 1;
+        if (photometricInterpretation === 'RGB') {
+            numberOfComponents = 3;
+        }
+        return numberOfComponents;
+    }
+    _getImageDataMetadata(image) {
+        const { imagePlaneModule, imagePixelModule } = this.buildMetadata(image.imageId);
+        let rowCosines, columnCosines;
+        rowCosines = imagePlaneModule.rowCosines;
+        columnCosines = imagePlaneModule.columnCosines;
+        if (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 scanAxisNormal = vec3.create();
+        vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+        let origin = imagePlaneModule.imagePositionPatient;
+        if (origin == null) {
+            origin = [0, 0, 0];
+        }
+        const xSpacing = imagePlaneModule.columnPixelSpacing || image.columnPixelSpacing;
+        const ySpacing = imagePlaneModule.rowPixelSpacing || image.rowPixelSpacing;
+        const xVoxels = image.columns;
+        const yVoxels = image.rows;
+        const zSpacing = image.sliceThickness || EPSILON;
+        const zVoxels = 1;
+        const numComps = image.numComps ||
+            this._getNumCompsFromPhotometricInterpretation(imagePixelModule.photometricInterpretation);
+        return {
+            bitsAllocated: imagePixelModule.bitsAllocated,
+            numComps,
+            origin,
+            direction: new Float32Array([
+                ...rowCosineVec,
+                ...colCosineVec,
+                ...scanAxisNormal,
+            ]),
+            dimensions: [xVoxels, yVoxels, zVoxels],
+            spacing: [xSpacing, ySpacing, zSpacing],
+            numVoxels: xVoxels * yVoxels * zVoxels,
+            imagePlaneModule,
+            imagePixelModule,
+        };
+    }
+    _getCameraOrientation(imageDataDirection) {
+        const viewPlaneNormal = imageDataDirection.slice(6, 9).map((x) => -x);
+        const viewUp = imageDataDirection.slice(3, 6).map((x) => -x);
+        return {
+            viewPlaneNormal: [
+                viewPlaneNormal[0],
+                viewPlaneNormal[1],
+                viewPlaneNormal[2],
+            ],
+            viewUp: [viewUp[0], viewUp[1], viewUp[2]],
+        };
+    }
+    _createVTKImageData(image) {
+        const { origin, direction, dimensions, spacing, bitsAllocated, numComps, numVoxels, } = this._getImageDataMetadata(image);
+        let pixelArray;
+        switch (bitsAllocated) {
+            case 8:
+                pixelArray = new Uint8Array(numVoxels);
+                break;
+            case 16:
+                pixelArray = new Float32Array(numVoxels);
+                break;
+            case 24:
+                pixelArray = new Uint8Array(numVoxels * 3);
+                break;
+            default:
+                console.debug('bit allocation not implemented');
+        }
+        const scalarArray = vtkDataArray.newInstance({
+            name: 'Pixels',
+            numberOfComponents: numComps,
+            values: pixelArray,
+        });
+        this._imageData = vtkImageData.newInstance();
+        this._imageData.setDimensions(dimensions);
+        this._imageData.setSpacing(spacing);
+        this._imageData.setDirection(direction);
+        this._imageData.setOrigin(origin);
+        this._imageData.getPointData().setScalars(scalarArray);
+    }
+    async setStack(imageIds, currentImageIdIndex = 0) {
+        this.imageIds = imageIds;
+        this.currentImageIdIndex = currentImageIdIndex;
+        this.stackInvalidated = true;
+        this.rotationCache = 0;
+        this.flipVertical = false;
+        this.flipHorizontal = false;
+        this._resetProperties();
+        this.fillWithBackgroundColor();
+        if (this.useCPURendering) {
+            this._cpuFallbackEnabledElement.renderingTools = {};
+            delete this._cpuFallbackEnabledElement.viewport.colormap;
+        }
+        const imageId = await this._setImageIdIndex(currentImageIdIndex);
+        return imageId;
+    }
+    _checkVTKImageDataMatchesCornerstoneImage(image, imageData) {
+        if (!imageData) {
+            return false;
+        }
+        const [xSpacing, ySpacing, zSpacing] = imageData.getSpacing();
+        const [xVoxels, yVoxels, zVoxels] = imageData.getDimensions();
+        const imagePlaneModule = metaData.get('imagePlaneModule', image.imageId);
+        const direction = imageData.getDirection();
+        const rowCosines = direction.slice(0, 3);
+        const columnCosines = direction.slice(3, 6);
+        if (xSpacing !== image.rowPixelSpacing ||
+            ySpacing !== image.columnPixelSpacing ||
+            xVoxels !== image.columns ||
+            yVoxels !== image.rows ||
+            !isEqual(imagePlaneModule.rowCosines, rowCosines) ||
+            !isEqual(imagePlaneModule.columnCosines, columnCosines)) {
+            return false;
+        }
+        return true;
+    }
+    _updateVTKImageDataFromCornerstoneImage(image) {
+        const imagePlaneModule = metaData.get('imagePlaneModule', image.imageId);
+        let origin = imagePlaneModule.imagePositionPatient;
+        if (origin == null) {
+            origin = [0, 0, 0];
+        }
+        this._imageData.setOrigin(origin);
+        const pixelData = image.getPixelData();
+        const scalars = this._imageData.getPointData().getScalars();
+        const scalarData = scalars.getData();
+        if (image.color) {
+            let j = 0;
+            for (let i = 0; i < pixelData.length; i += 4) {
+                scalarData[j] = pixelData[i];
+                scalarData[j + 1] = pixelData[i + 1];
+                scalarData[j + 2] = pixelData[i + 2];
+                j += 3;
+            }
+        }
+        else {
+            scalarData.set(pixelData);
+        }
+        this._imageData.modified();
+    }
+    async _loadImage(imageId, imageIdIndex) {
+        if (this.useCPURendering) {
+            await this._loadImageCPU(imageId, imageIdIndex);
+        }
+        else {
+            await this._loadImageGPU(imageId, imageIdIndex);
+        }
+        return imageId;
+    }
+    _loadImageCPU(imageId, imageIdIndex) {
+        return new Promise((resolve, reject) => {
+            function successCallback(image, imageIdIndex, imageId) {
+                const eventDetail = {
+                    image,
+                    imageId,
+                    viewportUID: this.uid,
+                    renderingEngineUID: this.renderingEngineUID,
+                };
+                triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
+                const metadata = this._getImageDataMetadata(image);
+                const viewport = getDefaultViewport(this.canvas, image, this.modality, this._cpuFallbackEnabledElement.viewport.colormap);
+                this._cpuFallbackEnabledElement.image = image;
+                this._cpuFallbackEnabledElement.metadata = {
+                    ...metadata,
+                };
+                this.cpuImagePixelData = image.getPixelData();
+                const viewportSettingToUse = Object.assign({}, viewport, this._cpuFallbackEnabledElement.viewport);
+                this._cpuFallbackEnabledElement.viewport = this.stackInvalidated
+                    ? viewport
+                    : viewportSettingToUse;
+                this.stackInvalidated = false;
+                this.cpuRenderingInvalidated = true;
+                this._cpuFallbackEnabledElement.transform = calculateTransform(this._cpuFallbackEnabledElement);
+                if (this.currentImageIdIndex !== imageIdIndex) {
+                    return;
+                }
+                this.render();
+                this.currentImageIdIndex = imageIdIndex;
+                resolve(imageId);
+            }
+            function errorCallback(error, imageIdIndex, imageId) {
+                const eventDetail = {
+                    error,
+                    imageIdIndex,
+                    imageId,
+                };
+                if (!this.suppressEvents) {
+                    triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+                }
+                reject(error);
+            }
+            function sendRequest(imageId, imageIdIndex, options) {
+                return loadAndCacheImage(imageId, options).then((image) => {
+                    successCallback.call(this, image, imageIdIndex, imageId);
+                }, (error) => {
+                    errorCallback.call(this, error, imageIdIndex, imageId);
+                });
+            }
+            const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+            const suvFactor = metaData.get('scalingModule', imageId) || {};
+            const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+            const scalingParameters = {
+                rescaleSlope: modalityLutModule.rescaleSlope,
+                rescaleIntercept: modalityLutModule.rescaleIntercept,
+                modality: generalSeriesModule.modality,
+                suvbw: suvFactor.suvbw,
+            };
+            const type = 'Float32Array';
+            const priority = -5;
+            const requestType = RequestType.Interaction;
+            const additionalDetails = { imageId };
+            const options = {
+                targetBuffer: {
+                    type,
+                    offset: null,
+                    length: null,
+                },
+                preScale: {
+                    scalingParameters,
+                },
+            };
+            imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
+        });
+    }
+    _loadImageGPU(imageId, imageIdIndex) {
+        return new Promise((resolve, reject) => {
+            function successCallback(image, imageIdIndex, imageId) {
+                const eventDetail = {
+                    image,
+                    imageId,
+                    viewportUID: this.uid,
+                    renderingEngineUID: this.renderingEngineUID,
+                };
+                triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
+                this._updateActorToDisplayImageId(image);
+                if (this.currentImageIdIndex !== imageIdIndex) {
+                    return;
+                }
+                this.render();
+                this.currentImageIdIndex = imageIdIndex;
+                resolve(imageId);
+            }
+            function errorCallback(error, imageIdIndex, imageId) {
+                const eventDetail = {
+                    error,
+                    imageIdIndex,
+                    imageId,
+                };
+                triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+                reject(error);
+            }
+            function sendRequest(imageId, imageIdIndex, options) {
+                return loadAndCacheImage(imageId, options).then((image) => {
+                    successCallback.call(this, image, imageIdIndex, imageId);
+                }, (error) => {
+                    errorCallback.call(this, error, imageIdIndex, imageId);
+                });
+            }
+            const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+            const suvFactor = metaData.get('scalingModule', imageId) || {};
+            const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+            const scalingParameters = {
+                rescaleSlope: modalityLutModule.rescaleSlope,
+                rescaleIntercept: modalityLutModule.rescaleIntercept,
+                modality: generalSeriesModule.modality,
+                suvbw: suvFactor.suvbw,
+            };
+            const type = 'Float32Array';
+            const priority = -5;
+            const requestType = RequestType.Interaction;
+            const additionalDetails = { imageId };
+            const options = {
+                targetBuffer: {
+                    type,
+                    offset: null,
+                    length: null,
+                },
+                preScale: {
+                    scalingParameters,
+                },
+            };
+            imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
+        });
+    }
+    _updateActorToDisplayImageId(image) {
+        const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
+        const activeCamera = this.getRenderer().getActiveCamera();
+        const previousCameraProps = _cloneDeep(this.getCamera());
+        if (sameImageData && !this.stackInvalidated) {
+            this._updateVTKImageDataFromCornerstoneImage(image);
+            const direction = this._imageData.getDirection();
+            const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);
+            this.setCameraNoEvent({ viewUp, viewPlaneNormal });
+            const cameraProps = this.getCamera();
+            this.panCache[0] = this.cameraPosOnRender[0] - cameraProps.position[0];
+            this.panCache[1] = this.cameraPosOnRender[1] - cameraProps.position[1];
+            this.panCache[2] = this.cameraPosOnRender[2] - cameraProps.position[2];
+            this.resetCameraNoEvent();
+            const { position } = this.getCamera();
+            this.cameraPosOnRender = position;
+            activeCamera.setFreezeFocalPoint(true);
+            this._restoreCameraProps(cameraProps, previousCameraProps);
+            this.rotationCache = 0;
+            this._setPropertiesFromCache();
+            return;
+        }
+        this._createVTKImageData(image);
+        this._updateVTKImageDataFromCornerstoneImage(image);
+        const stackActor = this.createActorMapper(this._imageData);
+        this.setActors([{ uid: this.uid, volumeActor: stackActor }]);
+        const direction = this._imageData.getDirection();
+        const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);
+        this.setCameraNoEvent({ viewUp, viewPlaneNormal });
+        this.resetCameraNoEvent();
+        this.triggerCameraEvent(this.getCamera(), previousCameraProps);
+        activeCamera.setFreezeFocalPoint(true);
+        this.setProperties();
+        const { position } = this.getCamera();
+        this.cameraPosOnRender = position;
+        this.stackInvalidated = false;
+        if (this._publishCalibratedEvent) {
+            this.triggerCalibrationEvent();
+        }
+    }
+    async _setImageIdIndex(imageIdIndex) {
+        if (imageIdIndex >= this.imageIds.length) {
+            throw new Error(`ImageIdIndex provided ${imageIdIndex} is invalid, the stack only has ${this.imageIds.length} elements`);
+        }
+        this.currentImageIdIndex = imageIdIndex;
+        const imageId = await this._loadImage(this.imageIds[imageIdIndex], imageIdIndex);
+        return imageId;
+    }
+    resetCamera(resetPanZoomForViewPlane = true) {
+        if (this.useCPURendering) {
+            this.resetCameraCPU(resetPanZoomForViewPlane);
+        }
+        else {
+            this.resetCameraGPU();
+        }
+        return true;
+    }
+    resetCameraCPU(resetPanZoomForViewPlane) {
+        const { image } = this._cpuFallbackEnabledElement;
+        if (!image) {
+            return;
+        }
+        resetCamera(this._cpuFallbackEnabledElement, resetPanZoomForViewPlane);
+    }
+    resetCameraGPU() {
+        const resetPanZoomForViewPlane = false;
+        super.resetCamera(resetPanZoomForViewPlane);
+    }
+    async setImageIdIndex(imageIdIndex) {
+        if (this.currentImageIdIndex === imageIdIndex) {
+            return;
+        }
+        const imageId = this._setImageIdIndex(imageIdIndex);
+        return imageId;
+    }
+    calibrateSpacing(imageId) {
+        const imageIdIndex = this.getImageIds().indexOf(imageId);
+        this.stackInvalidated = true;
+        this._loadImage(imageId, imageIdIndex);
+    }
+    _restoreCameraProps({ parallelScale: prevScale }, previousCamera) {
+        const renderer = this.getRenderer();
+        const { position, focalPoint } = this.getCamera();
+        const newPosition = [
+            position[0] - this.panCache[0],
+            position[1] - this.panCache[1],
+            position[2] - this.panCache[2],
+        ];
+        const newFocal = [
+            focalPoint[0] - this.panCache[0],
+            focalPoint[1] - this.panCache[1],
+            focalPoint[2] - this.panCache[2],
+        ];
+        this.setCameraNoEvent({
+            parallelScale: prevScale,
+            position: newPosition,
+            focalPoint: newFocal,
+        });
+        const camera = this.getCamera();
+        this.triggerCameraEvent(camera, previousCamera);
+        const RESET_CAMERA_EVENT = {
+            type: 'ResetCameraEvent',
+            renderer,
+        };
+        renderer.invokeEvent(RESET_CAMERA_EVENT);
+    }
+    triggerCameraEvent(camera, previousCamera) {
+        const eventDetail = {
+            previousCamera,
+            camera,
+            element: this.element,
+            viewportUID: this.uid,
+            renderingEngineUID: this.renderingEngineUID,
+        };
+        if (!this.suppressEvents) {
+            triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
+        }
+    }
+    triggerCalibrationEvent() {
+        const { imageData } = this.getImageData();
+        const eventDetail = {
+            element: this.element,
+            viewportUID: this.uid,
+            renderingEngineUID: this.renderingEngineUID,
+            imageId: this.getCurrentImageId(),
+            imageData: imageData,
+            worldToIndex: imageData.getWorldToIndex(),
+            ...this._calibrationEvent,
+        };
+        if (!this.suppressEvents) {
+            triggerEvent(this.element, Events.IMAGE_SPACING_CALIBRATED, eventDetail);
+        }
+        this._publishCalibratedEvent = false;
+    }
+    getRenderer() {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('getRenderer');
+        }
+        return super.getRenderer();
+    }
+    getDefaultActor() {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('getDefaultActor');
+        }
+        return super.getDefaultActor();
+    }
+    getActors() {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('getActors');
+        }
+        return super.getActors();
+    }
+    getActor(actorUID) {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('getActor');
+        }
+        return super.getActor(actorUID);
+    }
+    setActors(actors) {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('setActors');
+        }
+        return super.setActors(actors);
+    }
+    addActors(actors) {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('addActors');
+        }
+        return super.addActors(actors);
+    }
+    addActor(actorEntry) {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('addActor');
+        }
+        return super.addActor(actorEntry);
+    }
+    removeAllActors() {
+        if (this.useCPURendering) {
+            throw this.getCPUFallbackError('removeAllActors');
+        }
+        return super.removeAllActors();
+    }
+    getCPUFallbackError(method) {
+        return new Error(`method ${method} cannot be used during CPU Fallback mode`);
+    }
+    fillWithBackgroundColor() {
+        const renderingEngine = this.getRenderingEngine();
+        if (renderingEngine) {
+            renderingEngine.fillCanvasWithBackgroundColor(this.canvas, this.options.background);
+        }
+    }
+    setColormap(colormap) {
+        if (this.useCPURendering) {
+            this.setColormapCPU(colormap);
+        }
+        else {
+            this.setColormapGPU(colormap);
+        }
+    }
+    unsetColormap() {
+        if (this.useCPURendering) {
+            this.unsetColormapCPU();
+        }
+        else {
+            this.unsetColormapGPU();
+        }
+    }
+    unsetColormapCPU() {
+        delete this._cpuFallbackEnabledElement.viewport.colormap;
+        this._cpuFallbackEnabledElement.renderingTools = {};
+        this.cpuRenderingInvalidated = true;
+        this.fillWithBackgroundColor();
+        this.render();
+    }
+    setColormapCPU(colormapData) {
+        const colormap = getColormap(colormapData.name, colormapData);
+        this._cpuFallbackEnabledElement.viewport.colormap = colormap;
+        this._cpuFallbackEnabledElement.renderingTools = {};
+        this.fillWithBackgroundColor();
+        this.cpuRenderingInvalidated = true;
+        this.render();
+    }
+    setColormapGPU(colormap) {
+        throw new Error('setColorMapGPU not implemented.');
+    }
+    unsetColormapGPU() {
+        throw new Error('unsetColormapGPU not implemented.');
+    }
+}
+export default StackViewport;
+//# sourceMappingURL=StackViewport.js.map