@cornerstonejs/core 0.1.1

package/dist/cjs/RenderingEngine/StackViewport.js

@@ -0,0 +1,1151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DataArray_1 = __importDefault(require("vtk.js/Sources/Common/Core/DataArray"));
+const ImageData_1 = __importDefault(require("vtk.js/Sources/Common/DataModel/ImageData"));
+const Volume_1 = __importDefault(require("vtk.js/Sources/Rendering/Core/Volume"));
+const VolumeMapper_1 = __importDefault(require("vtk.js/Sources/Rendering/Core/VolumeMapper"));
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const Camera_1 = __importDefault(require("vtk.js/Sources/Rendering/Core/Camera"));
+const gl_matrix_1 = require("gl-matrix");
+const metaData_1 = __importDefault(require("../metaData"));
+const Viewport_1 = __importDefault(require("./Viewport"));
+const eventTarget_1 = __importDefault(require("../eventTarget"));
+const Events_1 = __importDefault(require("../enums/Events"));
+const utilities_1 = require("../utilities");
+const drawImageSync_1 = __importDefault(require("./helpers/cpuFallback/drawImageSync"));
+const index_1 = require("./helpers/cpuFallback/colors/index");
+const imageLoader_1 = require("../imageLoader");
+const imageLoadPoolManager_1 = __importDefault(require("../requestPool/imageLoadPoolManager"));
+const InterpolationType_1 = __importDefault(require("../enums/InterpolationType"));
+const canvasToPixel_1 = __importDefault(require("./helpers/cpuFallback/rendering/canvasToPixel"));
+const pixelToCanvas_1 = __importDefault(require("./helpers/cpuFallback/rendering/pixelToCanvas"));
+const getDefaultViewport_1 = __importDefault(require("./helpers/cpuFallback/rendering/getDefaultViewport"));
+const calculateTransform_1 = __importDefault(require("./helpers/cpuFallback/rendering/calculateTransform"));
+const resize_1 = __importDefault(require("./helpers/cpuFallback/rendering/resize"));
+const resetCamera_1 = __importDefault(require("./helpers/cpuFallback/rendering/resetCamera"));
+const transform_1 = require("./helpers/cpuFallback/rendering/transform");
+const init_1 = require("../init");
+const RequestType_1 = __importDefault(require("../enums/RequestType"));
+const EPSILON = 1;
+class StackViewport extends Viewport_1.default {
+    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) {
+                (0, resize_1.default)(this._cpuFallbackEnabledElement);
+            }
+        };
+        this.getFrameOfReferenceUID = () => {
+            const imageId = this.getCurrentImageId();
+            if (!imageId) {
+                return;
+            }
+            const imagePlaneModule = metaData_1.default.get('imagePlaneModule', imageId);
+            if (!imagePlaneModule) {
+                return;
+            }
+            return imagePlaneModule.frameOfReferenceUID;
+        };
+        this.createActorMapper = (imageData) => {
+            const mapper = VolumeMapper_1.default.newInstance();
+            mapper.setInputData(imageData);
+            const actor = Volume_1.default.newInstance();
+            actor.setMapper(mapper);
+            const [xSize, ySize, zSize] = imageData.getDimensions();
+            const [xSpacing, ySpacing, zSpacing] = imageData.getSpacing();
+            const vSize = gl_matrix_1.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] = (0, canvasToPixel_1.default)(this._cpuFallbackEnabledElement, canvasPos);
+            const { origin, spacing, direction } = this.getImageData();
+            const worldPos = gl_matrix_1.vec3.fromValues(0, 0, 0);
+            const iVector = direction.slice(0, 3);
+            const jVector = direction.slice(3, 6);
+            gl_matrix_1.vec3.scaleAndAdd(worldPos, origin, iVector, px * spacing[0]);
+            gl_matrix_1.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 = gl_matrix_1.vec3.subtract(gl_matrix_1.vec3.create(), worldPos, origin);
+            const worldPoint = [
+                gl_matrix_1.vec3.dot(diff, iVector) / spacing[0],
+                gl_matrix_1.vec3.dot(diff, jVector) / spacing[1],
+            ];
+            const canvasPoint = (0, pixelToCanvas_1.default)(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) {
+                (0, drawImageSync_1.default)(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 = (0, init_1.getShouldUseCPURendering)();
+        if (this.useCPURendering) {
+            this._cpuFallbackEnabledElement = {
+                canvas: this.canvas,
+                renderingTools: {},
+                transform: new transform_1.Transform(),
+                viewport: {},
+            };
+        }
+        else {
+            const renderer = this.getRenderer();
+            const camera = Camera_1.default.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 (0, init_1.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 = (0, canvasToPixel_1.default)(this._cpuFallbackEnabledElement, canvasPoint);
+                    return [pixelCoord[0], pixelCoord[1], 0];
+                },
+                indexToWorld: (point) => {
+                    const canvasPoint = (0, pixelToCanvas_1.default)(this._cpuFallbackEnabledElement, [
+                        point[0],
+                        point[1],
+                    ]);
+                    return this.canvasToWorldCPU(canvasPoint);
+                },
+            },
+            scalarData: this.cpuImagePixelData,
+        };
+    }
+    buildMetadata(imageId) {
+        const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData_1.default.get('imagePixelModule', imageId);
+        const voiLutModule = metaData_1.default.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_1.default.get('generalSeriesModule', imageId);
+        const imageIdScalingFactor = metaData_1.default.get('scalingModule', imageId);
+        if (modality === 'PT' && imageIdScalingFactor) {
+            this._addScalingToViewport(imageIdScalingFactor);
+        }
+        this.modality = modality;
+        let imagePlaneModule = metaData_1.default.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_1.default.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_1.default.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 = gl_matrix_1.vec2.create();
+            gl_matrix_1.vec2.subtract(deltaCanvas, gl_matrix_1.vec2.fromValues(previousFocalPointCanvas[0], previousFocalPointCanvas[1]), gl_matrix_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 = Object.assign(Object.assign({}, previousCamera), { focalPoint,
+            viewUp,
+            parallelScale });
+        const eventDetail = {
+            previousCamera,
+            camera: updatedCamera,
+            element: this.element,
+            viewportUID: this.uid,
+            renderingEngineUID: this.renderingEngineUID,
+        };
+        (0, utilities_1.triggerEvent)(this.element, Events_1.default.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_1.default.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)) {
+            (0, utilities_1.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 } = utilities_1.windowLevel.toLowHighRange(wwToUse, wcToUse);
+            this.voiRange = { lower, upper };
+        }
+        else {
+            const { lower, upper } = voiRange;
+            const { windowCenter, windowWidth } = utilities_1.windowLevel.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 = gl_matrix_1.vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+        const colCosineVec = gl_matrix_1.vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        const scanAxisNormal = gl_matrix_1.vec3.create();
+        gl_matrix_1.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 = DataArray_1.default.newInstance({
+            name: 'Pixels',
+            numberOfComponents: numComps,
+            values: pixelArray,
+        });
+        this._imageData = ImageData_1.default.newInstance();
+        this._imageData.setDimensions(dimensions);
+        this._imageData.setSpacing(spacing);
+        this._imageData.setDirection(direction);
+        this._imageData.setOrigin(origin);
+        this._imageData.getPointData().setScalars(scalarArray);
+    }
+    setStack(imageIds, currentImageIdIndex = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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_1.default.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 ||
+            !(0, utilities_1.isEqual)(imagePlaneModule.rowCosines, rowCosines) ||
+            !(0, utilities_1.isEqual)(imagePlaneModule.columnCosines, columnCosines)) {
+            return false;
+        }
+        return true;
+    }
+    _updateVTKImageDataFromCornerstoneImage(image) {
+        const imagePlaneModule = metaData_1.default.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();
+    }
+    _loadImage(imageId, imageIdIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.useCPURendering) {
+                yield this._loadImageCPU(imageId, imageIdIndex);
+            }
+            else {
+                yield 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,
+                };
+                (0, utilities_1.triggerEvent)(this.element, Events_1.default.STACK_NEW_IMAGE, eventDetail);
+                const metadata = this._getImageDataMetadata(image);
+                const viewport = (0, getDefaultViewport_1.default)(this.canvas, image, this.modality, this._cpuFallbackEnabledElement.viewport.colormap);
+                this._cpuFallbackEnabledElement.image = image;
+                this._cpuFallbackEnabledElement.metadata = Object.assign({}, 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 = (0, calculateTransform_1.default)(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) {
+                    (0, utilities_1.triggerEvent)(eventTarget_1.default, Events_1.default.IMAGE_LOAD_ERROR, eventDetail);
+                }
+                reject(error);
+            }
+            function sendRequest(imageId, imageIdIndex, options) {
+                return (0, imageLoader_1.loadAndCacheImage)(imageId, options).then((image) => {
+                    successCallback.call(this, image, imageIdIndex, imageId);
+                }, (error) => {
+                    errorCallback.call(this, error, imageIdIndex, imageId);
+                });
+            }
+            const modalityLutModule = metaData_1.default.get('modalityLutModule', imageId) || {};
+            const suvFactor = metaData_1.default.get('scalingModule', imageId) || {};
+            const generalSeriesModule = metaData_1.default.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_1.default.Interaction;
+            const additionalDetails = { imageId };
+            const options = {
+                targetBuffer: {
+                    type,
+                    offset: null,
+                    length: null,
+                },
+                preScale: {
+                    scalingParameters,
+                },
+            };
+            imageLoadPoolManager_1.default.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,
+                };
+                (0, utilities_1.triggerEvent)(this.element, Events_1.default.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,
+                };
+                (0, utilities_1.triggerEvent)(eventTarget_1.default, Events_1.default.IMAGE_LOAD_ERROR, eventDetail);
+                reject(error);
+            }
+            function sendRequest(imageId, imageIdIndex, options) {
+                return (0, imageLoader_1.loadAndCacheImage)(imageId, options).then((image) => {
+                    successCallback.call(this, image, imageIdIndex, imageId);
+                }, (error) => {
+                    errorCallback.call(this, error, imageIdIndex, imageId);
+                });
+            }
+            const modalityLutModule = metaData_1.default.get('modalityLutModule', imageId) || {};
+            const suvFactor = metaData_1.default.get('scalingModule', imageId) || {};
+            const generalSeriesModule = metaData_1.default.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_1.default.Interaction;
+            const additionalDetails = { imageId };
+            const options = {
+                targetBuffer: {
+                    type,
+                    offset: null,
+                    length: null,
+                },
+                preScale: {
+                    scalingParameters,
+                },
+            };
+            imageLoadPoolManager_1.default.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 = (0, lodash_clonedeep_1.default)(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();
+        }
+    }
+    _setImageIdIndex(imageIdIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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;
+        }
+        (0, resetCamera_1.default)(this._cpuFallbackEnabledElement, resetPanZoomForViewPlane);
+    }
+    resetCameraGPU() {
+        const resetPanZoomForViewPlane = false;
+        super.resetCamera(resetPanZoomForViewPlane);
+    }
+    setImageIdIndex(imageIdIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+            (0, utilities_1.triggerEvent)(this.element, Events_1.default.CAMERA_MODIFIED, eventDetail);
+        }
+    }
+    triggerCalibrationEvent() {
+        const { imageData } = this.getImageData();
+        const eventDetail = Object.assign({ element: this.element, viewportUID: this.uid, renderingEngineUID: this.renderingEngineUID, imageId: this.getCurrentImageId(), imageData: imageData, worldToIndex: imageData.getWorldToIndex() }, this._calibrationEvent);
+        if (!this.suppressEvents) {
+            (0, utilities_1.triggerEvent)(this.element, Events_1.default.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 = (0, index_1.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.');
+    }
+}
+exports.default = StackViewport;
+//# sourceMappingURL=StackViewport.js.map