@cornerstonejs/core 0.33.0 → 0.33.1

package/dist/cjs/RenderingEngine/StackViewport.js

@@ -70,9 +70,9 @@ const EPSILON = 1;
 class StackViewport extends Viewport_1.default {
     constructor(props) {
         super(props);
+        this.voiUpdatedWithSetProperties = false;
         this.invert = false;
         this.stackInvalidated = false;
-        this.voiApplied = false;
         this._publishCalibratedEvent = false;
         this.resize = () => {
             if (this.useCPURendering) {
@@ -106,22 +106,16 @@ class StackViewport extends Viewport_1.default {
             return actor;
         };
         this.getProperties = () => {
+            const { voiRange, VOILUTFunction, interpolationType, invert } = this;
+            const rotation = this.getRotation();
             return {
-                voiRange: this.voiRange,
-                rotation: this.getRotation(),
-                VOILUTFunction: this.VOILUTFunction,
-                interpolationType: this.interpolationType,
-                invert: this.invert,
+                voiRange,
+                VOILUTFunction,
+                interpolationType,
+                invert,
+                rotation,
             };
         };
-        this.getRotation = () => {
-            if (this.useCPURendering) {
-                return this.getRotationCPU();
-            }
-            else {
-                return this.getRotationGPU();
-            }
-        };
         this.getRotationCPU = () => {
             const { viewport } = this._cpuFallbackEnabledElement;
             return viewport.rotation;
@@ -138,18 +132,6 @@ class StackViewport extends Viewport_1.default {
                 ? initialToCurrentViewUpAngle
                 : (360 - initialToCurrentViewUpAngle) % 360;
         };
-        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;
@@ -262,9 +244,98 @@ class StackViewport extends Viewport_1.default {
                 renderingEngineId: this.renderingEngineId,
             };
         };
+        this.renderingPipelineFunctions = {
+            getImageData: {
+                cpu: this.getImageDataCPU,
+                gpu: this.getImageDataGPU,
+            },
+            setColormap: {
+                cpu: this.setColormapCPU,
+                gpu: this.setColormapGPU,
+            },
+            getCamera: {
+                cpu: this.getCameraCPU,
+                gpu: super.getCamera,
+            },
+            setCamera: {
+                cpu: this.setCameraCPU,
+                gpu: super.setCamera,
+            },
+            setVOI: {
+                cpu: this.setVOICPU,
+                gpu: this.setVOIGPU,
+            },
+            getRotation: {
+                cpu: this.getRotationCPU,
+                gpu: this.getRotationGPU,
+            },
+            setInterpolationType: {
+                cpu: this.setInterpolationTypeCPU,
+                gpu: this.setInterpolationTypeGPU,
+            },
+            setInvertColor: {
+                cpu: this.setInvertColorCPU,
+                gpu: this.setInvertColorGPU,
+            },
+            resetCamera: {
+                cpu: (resetPan = true, resetZoom = true) => {
+                    this.resetCameraCPU(resetPan, resetZoom);
+                    return true;
+                },
+                gpu: (resetPan = true, resetZoom = true) => {
+                    this.resetCameraGPU(resetPan, resetZoom);
+                    return true;
+                },
+            },
+            canvasToWorld: {
+                cpu: this.canvasToWorldCPU,
+                gpu: this.canvasToWorldGPU,
+            },
+            worldToCanvas: {
+                cpu: this.worldToCanvasCPU,
+                gpu: this.worldToCanvasGPU,
+            },
+            getRenderer: {
+                cpu: () => this.getCPUFallbackError('getRenderer'),
+                gpu: super.getRenderer,
+            },
+            getDefaultActor: {
+                cpu: () => this.getCPUFallbackError('getDefaultActor'),
+                gpu: super.getDefaultActor,
+            },
+            getActors: {
+                cpu: () => this.getCPUFallbackError('getActors'),
+                gpu: super.getActors,
+            },
+            getActor: {
+                cpu: () => this.getCPUFallbackError('getActor'),
+                gpu: super.getActor,
+            },
+            setActors: {
+                cpu: () => this.getCPUFallbackError('setActors'),
+                gpu: super.setActors,
+            },
+            addActors: {
+                cpu: () => this.getCPUFallbackError('addActors'),
+                gpu: super.addActors,
+            },
+            addActor: {
+                cpu: () => this.getCPUFallbackError('addActor'),
+                gpu: super.addActor,
+            },
+            removeAllActors: {
+                cpu: () => this.getCPUFallbackError('removeAllActors'),
+                gpu: super.removeAllActors,
+            },
+            unsetColormap: {
+                cpu: this.unsetColormapCPU,
+                gpu: this.unsetColormapGPU,
+            },
+        };
         this.scaling = {};
         this.modality = null;
         this.useCPURendering = (0, init_1.getShouldUseCPURendering)();
+        this._configureRenderingPipeline();
         if (this.useCPURendering) {
             this._cpuFallbackEnabledElement = {
                 canvas: this.canvas,
@@ -295,20 +366,21 @@ class StackViewport extends Viewport_1.default {
     static get useCustomRenderingPipeline() {
         return (0, init_1.getShouldUseCPURendering)();
     }
+    setUseCPURendering(value) {
+        this.useCPURendering = value;
+        this._configureRenderingPipeline();
+    }
+    _configureRenderingPipeline() {
+        for (const [funcName, functions] of Object.entries(this.renderingPipelineFunctions)) {
+            this[funcName] = this.useCPURendering ? functions.cpu : functions.gpu;
+        }
+    }
     initializeElementDisabledHandler() {
         eventTarget_1.default.addEventListener(Events_1.default.ELEMENT_DISABLED, function elementDisabledHandler() {
             clearTimeout(this.debouncedTimeout);
             eventTarget_1.default.removeEventListener(Events_1.default.ELEMENT_DISABLED, elementDisabledHandler);
         });
     }
-    getImageData() {
-        if (this.useCPURendering) {
-            return this.getImageDataCPU();
-        }
-        else {
-            return this.getImageDataGPU();
-        }
-    }
     getImageDataGPU() {
         const defaultActor = this.getDefaultActor();
         if (!defaultActor) {
@@ -365,28 +437,18 @@ class StackViewport extends Viewport_1.default {
             preScale: Object.assign({}, this.csImage.preScale),
         };
     }
-    buildMetadata(imageId) {
+    buildMetadata(image) {
+        const imageId = image.imageId;
         const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId);
-        const voiLutModule = metaData.get('voiLutModule', imageId);
-        let windowWidth, windowCenter, voiLUTFunction;
-        if (voiLutModule) {
-            ({ windowWidth, windowCenter, voiLUTFunction } = voiLutModule);
-            if (Array.isArray(windowWidth)) {
-                windowWidth = windowWidth[0];
-            }
-            if (Array.isArray(windowCenter)) {
-                windowCenter = windowCenter[0];
-            }
-            if (Object.values(VOILUTFunctionType_1.default).indexOf(voiLUTFunction) === -1) {
-                voiLUTFunction = VOILUTFunctionType_1.default.LINEAR;
-            }
-        }
+        const { windowWidth, windowCenter, voiLUTFunction } = image;
         const { modality } = metaData.get('generalSeriesModule', imageId);
         const imageIdScalingFactor = metaData.get('scalingModule', imageId);
         if (modality === 'PT' && imageIdScalingFactor) {
             this._addScalingToViewport(imageIdScalingFactor);
         }
         this.modality = modality;
+        const voiLUTFunctionEnum = this._getValidVOILUTFunction(voiLUTFunction);
+        this.VOILUTFunction = voiLUTFunctionEnum;
         let imagePlaneModule = this._getImagePlaneModule(imageId);
         if (!this.useCPURendering) {
             imagePlaneModule = this.calibrateIfNecessary(imageId, imagePlaneModule);
@@ -402,8 +464,8 @@ class StackViewport extends Viewport_1.default {
                 pixelRepresentation,
                 windowWidth,
                 windowCenter,
-                voiLUTFunction,
                 modality,
+                voiLUTFunction: voiLUTFunctionEnum,
             },
         };
     }
@@ -451,8 +513,9 @@ class StackViewport extends Viewport_1.default {
         return imagePlaneModule;
     }
     setProperties({ voiRange, VOILUTFunction, invert, interpolationType, rotation, } = {}, suppressEvents = false) {
-        if (typeof voiRange !== 'undefined' || !this.voiApplied) {
-            this.setVOI(voiRange, suppressEvents);
+        if (typeof voiRange !== 'undefined') {
+            const voiUpdatedWithSetProperties = true;
+            this.setVOI(voiRange, { suppressEvents, voiUpdatedWithSetProperties });
         }
         if (typeof VOILUTFunction !== 'undefined') {
             this.setVOILUTFunction(VOILUTFunction, suppressEvents);
@@ -471,6 +534,7 @@ class StackViewport extends Viewport_1.default {
     }
     resetProperties() {
         this.cpuRenderingInvalidated = true;
+        this.voiUpdatedWithSetProperties = false;
         this.fillWithBackgroundColor();
         if (this.useCPURendering) {
             this._cpuFallbackEnabledElement.renderingTools = {};
@@ -478,38 +542,37 @@ class StackViewport extends Viewport_1.default {
         this._resetProperties();
         this.render();
     }
-    getCamera() {
-        if (this.useCPURendering) {
-            return this.getCameraCPU();
+    _resetProperties() {
+        let voiRange;
+        if (this._isCurrentImagePTPrescaled()) {
+            voiRange = this._getDefaultPTPrescaledVOIRange();
         }
         else {
-            return super.getCamera();
+            voiRange = this._getVOIRangeForCurrentImage();
         }
+        this.setVOI(voiRange);
+        if (this.getRotation() !== 0) {
+            this.setRotation(0);
+        }
+        this.setInterpolationType(InterpolationType_1.default.LINEAR);
+        this.setInvertColor(false);
     }
-    setCamera(cameraInterface, storeAsInitialCamera = false) {
-        if (this.useCPURendering) {
-            this.setCameraCPU(cameraInterface);
+    _setPropertiesFromCache() {
+        var _a;
+        const { interpolationType, invert } = this;
+        let voiRange;
+        if (this.voiUpdatedWithSetProperties) {
+            voiRange = this.voiRange;
+        }
+        else if (this._isCurrentImagePTPrescaled()) {
+            voiRange = this._getDefaultPTPrescaledVOIRange();
         }
         else {
-            super.setCamera(cameraInterface, storeAsInitialCamera);
+            voiRange = (_a = this._getVOIRangeForCurrentImage()) !== null && _a !== void 0 ? _a : this.voiRange;
         }
-    }
-    _resetProperties() {
-        this.voiApplied = false;
-        this.setProperties({
-            voiRange: this.initialVOIRange,
-            rotation: 0,
-            interpolationType: InterpolationType_1.default.LINEAR,
-            invert: false,
-        });
-    }
-    _setPropertiesFromCache() {
-        const suppressEvents = true;
-        this.setProperties({
-            voiRange: this.voiRange,
-            interpolationType: this.interpolationType,
-            invert: this.invert,
-        }, suppressEvents);
+        this.setVOI(voiRange);
+        this.setInterpolationType(interpolationType);
+        this.setInvertColor(invert);
     }
     getCameraCPU() {
         const { metadata, viewport } = this._cpuFallbackEnabledElement;
@@ -596,21 +659,11 @@ class StackViewport extends Viewport_1.default {
             this.flipVertical = viewport.vflip;
         }
     }
-    setVOI(voiRange, suppressEvents) {
-        if (this.useCPURendering) {
-            this.setVOICPU(voiRange, suppressEvents);
-            return;
-        }
-        this.setVOIGPU(voiRange, suppressEvents);
-    }
     setRotation(rotation) {
         const previousCamera = this.getCamera();
-        if (this.useCPURendering) {
-            this.setRotationCPU(rotation);
-        }
-        else {
-            this.setRotationGPU(rotation);
-        }
+        this.useCPURendering
+            ? this.setRotationCPU(rotation)
+            : this.setRotationGPU(rotation);
         const camera = this.getCamera();
         const eventDetail = {
             previousCamera,
@@ -626,26 +679,15 @@ class StackViewport extends Viewport_1.default {
         if (this.useCPURendering) {
             throw new Error('VOI LUT function is not supported in CPU rendering');
         }
-        if (Object.values(VOILUTFunctionType_1.default).indexOf(voiLUTFunction) === -1) {
-            voiLUTFunction = VOILUTFunctionType_1.default.LINEAR;
+        const newVOILUTFunction = this._getValidVOILUTFunction(voiLUTFunction);
+        let forceRecreateLUTFunction = false;
+        if (this.VOILUTFunction !== VOILUTFunctionType_1.default.LINEAR &&
+            newVOILUTFunction === VOILUTFunctionType_1.default.LINEAR) {
+            forceRecreateLUTFunction = true;
         }
-        this.VOILUTFunction = voiLUTFunction;
+        this.VOILUTFunction = newVOILUTFunction;
         const { voiRange } = this.getProperties();
-        this.setVOI(voiRange, suppressEvents);
-    }
-    setInterpolationType(interpolationType) {
-        if (this.useCPURendering) {
-            this.setInterpolationTypeCPU(interpolationType);
-            return;
-        }
-        this.setInterpolationTypeGPU(interpolationType);
-    }
-    setInvertColor(invert) {
-        if (this.useCPURendering) {
-            this.setInvertColorCPU(invert);
-            return;
-        }
-        this.setInvertColorGPU(invert);
+        this.setVOI(voiRange, { suppressEvents, forceRecreateLUTFunction });
     }
     setRotationCPU(rotation) {
         const { viewport } = this._cpuFallbackEnabledElement;
@@ -676,12 +718,8 @@ class StackViewport extends Viewport_1.default {
     }
     setInterpolationTypeCPU(interpolationType) {
         const { viewport } = this._cpuFallbackEnabledElement;
-        if (interpolationType === InterpolationType_1.default.LINEAR) {
-            viewport.pixelReplication = false;
-        }
-        else {
-            viewport.pixelReplication = true;
-        }
+        viewport.pixelReplication =
+            interpolationType === InterpolationType_1.default.LINEAR ? false : true;
         this.interpolationType = interpolationType;
     }
     setInvertColorCPU(invert) {
@@ -717,7 +755,8 @@ class StackViewport extends Viewport_1.default {
             this.invert = invert;
         }
     }
-    setVOICPU(voiRange, suppressEvents) {
+    setVOICPU(voiRange, options = {}) {
+        const { suppressEvents = false } = options;
         const { viewport, image } = this._cpuFallbackEnabledElement;
         if (!viewport || !image) {
             return;
@@ -745,7 +784,6 @@ class StackViewport extends Viewport_1.default {
             viewport.voi.windowWidth = windowWidth;
             viewport.voi.windowCenter = windowCenter;
         }
-        this.voiApplied = true;
         this.voiRange = voiRange;
         const eventDetail = {
             viewportId: this.id,
@@ -755,7 +793,15 @@ class StackViewport extends Viewport_1.default {
             (0, utilities_1.triggerEvent)(this.element, Events_1.default.VOI_MODIFIED, eventDetail);
         }
     }
-    setVOIGPU(voiRange, suppressEvents) {
+    setVOIGPU(voiRange, options = {}) {
+        const { suppressEvents = false, forceRecreateLUTFunction = false, voiUpdatedWithSetProperties = false, } = options;
+        if (voiRange &&
+            this.voiRange &&
+            this.voiRange.lower === voiRange.lower &&
+            this.voiRange.upper === voiRange.upper &&
+            !forceRecreateLUTFunction) {
+            return;
+        }
         const defaultActor = this.getDefaultActor();
         if (!defaultActor) {
             return;
@@ -763,8 +809,7 @@ class StackViewport extends Viewport_1.default {
         if (!(0, utilities_1.isImageActor)(defaultActor)) {
             return;
         }
-        const { actor } = defaultActor;
-        const imageActor = actor;
+        const imageActor = defaultActor.actor;
         let voiRangeToUse = voiRange;
         if (typeof voiRangeToUse === 'undefined') {
             const imageData = imageActor.getMapper().getInputData();
@@ -773,43 +818,48 @@ class StackViewport extends Viewport_1.default {
             voiRangeToUse = maxVoiRange;
         }
         imageActor.getProperty().setUseLookupTableScalarRange(true);
-        if (this.VOILUTFunction === VOILUTFunctionType_1.default.SAMPLED_SIGMOID) {
-            const cfun = (0, utilities_1.createSigmoidRGBTransferFunction)(voiRangeToUse);
+        let transferFunction = imageActor.getProperty().getRGBTransferFunction(0);
+        const isSigmoidTFun = this.VOILUTFunction === VOILUTFunctionType_1.default.SAMPLED_SIGMOID;
+        if (isSigmoidTFun || !transferFunction || forceRecreateLUTFunction) {
+            const transferFunctionCreator = isSigmoidTFun
+                ? utilities_1.createSigmoidRGBTransferFunction
+                : createLinearRGBTransferFunction_1.default;
+            transferFunction = transferFunctionCreator(voiRangeToUse);
             if (this.invert) {
-                (0, utilities_1.invertRgbTransferFunction)(cfun);
+                (0, utilities_1.invertRgbTransferFunction)(transferFunction);
             }
-            imageActor.getProperty().setRGBTransferFunction(0, cfun);
+            imageActor.getProperty().setRGBTransferFunction(0, transferFunction);
         }
-        else {
-            const cfun = (0, createLinearRGBTransferFunction_1.default)(voiRangeToUse);
-            if (this.invert) {
-                (0, utilities_1.invertRgbTransferFunction)(cfun);
-            }
-            imageActor.getProperty().setRGBTransferFunction(0, cfun);
+        if (!isSigmoidTFun) {
+            transferFunction.setRange(voiRangeToUse.lower, voiRangeToUse.upper);
         }
-        this.voiApplied = true;
         this.voiRange = voiRangeToUse;
-        if (!suppressEvents) {
-            const eventDetail = {
-                viewportId: this.id,
-                range: voiRangeToUse,
-                VOILUTFunction: this.VOILUTFunction,
-            };
-            (0, utilities_1.triggerEvent)(this.element, Events_1.default.VOI_MODIFIED, eventDetail);
+        if (!this.voiUpdatedWithSetProperties) {
+            this.voiUpdatedWithSetProperties = voiUpdatedWithSetProperties;
         }
+        if (suppressEvents) {
+            return;
+        }
+        const eventDetail = {
+            viewportId: this.id,
+            range: voiRangeToUse,
+            VOILUTFunction: this.VOILUTFunction,
+        };
+        (0, utilities_1.triggerEvent)(this.element, Events_1.default.VOI_MODIFIED, eventDetail);
     }
     _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;
+        if (this.scaling.PET) {
+            return;
         }
+        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;
@@ -821,7 +871,7 @@ class StackViewport extends Viewport_1.default {
         return numberOfComponents;
     }
     _getImageDataMetadata(image) {
-        const { imagePlaneModule, imagePixelModule } = this.buildMetadata(image.imageId);
+        const { imagePlaneModule, imagePixelModule } = this.buildMetadata(image);
         let rowCosines, columnCosines;
         rowCosines = imagePlaneModule.rowCosines;
         columnCosines = imagePlaneModule.columnCosines;
@@ -904,8 +954,9 @@ class StackViewport extends Viewport_1.default {
             this.stackInvalidated = true;
             this.flipVertical = false;
             this.flipHorizontal = false;
-            this.voiApplied = false;
-            this._resetProperties();
+            this.voiRange = null;
+            this.interpolationType = InterpolationType_1.default.LINEAR;
+            this.invert = false;
             this.fillWithBackgroundColor();
             if (this.useCPURendering) {
                 this._cpuFallbackEnabledElement.renderingTools = {};
@@ -972,12 +1023,9 @@ class StackViewport extends Viewport_1.default {
     }
     _loadAndDisplayImage(imageId, imageIdIndex) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.useCPURendering) {
-                yield this._loadAndDisplayImageCPU(imageId, imageIdIndex);
-            }
-            else {
-                yield this._loadAndDisplayImageGPU(imageId, imageIdIndex);
-            }
+            yield (this.useCPURendering
+                ? this._loadAndDisplayImageCPU(imageId, imageIdIndex)
+                : this._loadAndDisplayImageGPU(imageId, imageIdIndex));
             return imageId;
         });
     }
@@ -988,6 +1036,7 @@ class StackViewport extends Viewport_1.default {
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
+                image.isPreScaled = (_a = image.preScale) === null || _a === void 0 ? void 0 : _a.scaled;
                 this.csImage = image;
                 const eventDetail = {
                     image,
@@ -998,7 +1047,6 @@ class StackViewport extends Viewport_1.default {
                 };
                 (0, utilities_1.triggerEvent)(this.element, Events_1.default.STACK_NEW_IMAGE, eventDetail);
                 const metadata = this._getImageDataMetadata(image);
-                image.isPreScaled = (_a = image.preScale) === null || _a === void 0 ? void 0 : _a.scaled;
                 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);
@@ -1053,9 +1101,11 @@ class StackViewport extends Viewport_1.default {
     _loadAndDisplayImageGPU(imageId, imageIdIndex) {
         return new Promise((resolve, reject) => {
             function successCallback(image, imageIdIndex, imageId) {
+                var _a;
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
+                image.isPreScaled = (_a = image.preScale) === null || _a === void 0 ? void 0 : _a.scaled;
                 this.csImage = image;
                 const eventDetail = {
                     image,
@@ -1112,7 +1162,6 @@ class StackViewport extends Viewport_1.default {
         });
     }
     _updateActorToDisplayImageId(image) {
-        var _a;
         const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
         const activeCamera = this.getRenderer().getActiveCamera();
         const previousCameraProps = (0, lodash_clonedeep_1.default)(this.getCamera());
@@ -1154,41 +1203,43 @@ class StackViewport extends Viewport_1.default {
         this.resetCameraNoEvent();
         this.triggerCameraEvent(this.getCamera(), previousCameraProps);
         activeCamera.setFreezeFocalPoint(true);
-        const { windowCenter, windowWidth, voiLUTFunction } = imagePixelModule;
-        let voiRange = typeof windowCenter === 'number' && typeof windowWidth === 'number'
-            ? utilities_1.windowLevel.toLowHighRange(windowWidth, windowCenter)
-            : undefined;
-        const isPreScaled = this.csImage.isPreScaled || ((_a = this.csImage.preScale) === null || _a === void 0 ? void 0 : _a.scaled);
-        if (imagePixelModule.modality === 'PT' && isPreScaled) {
-            voiRange = { lower: 0, upper: 5 };
-        }
-        this.initialVOIRange = voiRange;
-        if (this.voiApplied && typeof voiRange === 'undefined') {
-            voiRange = this.voiRange;
-        }
-        if (Object.values(VOILUTFunctionType_1.default).indexOf(voiLUTFunction) === -1) {
-            this.VOILUTFunction = VOILUTFunctionType_1.default.LINEAR;
-        }
-        else {
-            this.VOILUTFunction = voiLUTFunction;
-        }
-        this.setProperties({ voiRange });
-        if (actor.getProperty().getRGBTransferFunction(0) === null) {
-            const cfun = (0, createLinearRGBTransferFunction_1.default)(voiRange);
-            actor.getProperty().setRGBTransferFunction(0, cfun);
-        }
-        let invert = false;
-        if (imagePixelModule.photometricInterpretation === 'MONOCHROME1') {
-            invert = true;
-        }
-        this.setProperties({ invert });
-        const { focalPoint } = this.getCamera();
-        this.cameraFocalPointOnRender = focalPoint;
+        this.setVOI(this._getInitialVOIRange(image));
+        this.setInvertColor(imagePixelModule.photometricInterpretation === 'MONOCHROME1');
+        this.cameraFocalPointOnRender = this.getCamera().focalPoint;
         this.stackInvalidated = false;
         if (this._publishCalibratedEvent) {
             this.triggerCalibrationEvent();
         }
     }
+    _getInitialVOIRange(image) {
+        if (this.voiRange && this.voiUpdatedWithSetProperties) {
+            return this.voiRange;
+        }
+        const { windowCenter, windowWidth } = image;
+        let voiRange = this._getVOIRangeFromWindowLevel(windowWidth, windowCenter);
+        voiRange = this._getPTPreScaledRange() || voiRange;
+        return voiRange;
+    }
+    _getPTPreScaledRange() {
+        if (!this._isCurrentImagePTPrescaled()) {
+            return undefined;
+        }
+        return this._getDefaultPTPrescaledVOIRange();
+    }
+    _isCurrentImagePTPrescaled() {
+        if (this.modality !== 'PT' || !this.csImage.isPreScaled) {
+            return false;
+        }
+        return true;
+    }
+    _getDefaultPTPrescaledVOIRange() {
+        return { lower: 0, upper: 5 };
+    }
+    _getVOIRangeFromWindowLevel(windowWidth, windowCenter) {
+        return typeof windowCenter === 'number' && typeof windowWidth === 'number'
+            ? utilities_1.windowLevel.toLowHighRange(windowWidth, windowCenter)
+            : undefined;
+    }
     _setImageIdIndex(imageIdIndex) {
         return __awaiter(this, void 0, void 0, function* () {
             if (imageIdIndex >= this.imageIds.length) {
@@ -1200,15 +1251,6 @@ class StackViewport extends Viewport_1.default {
             return imageId;
         });
     }
-    resetCamera(resetPan = true, resetZoom = true) {
-        if (this.useCPURendering) {
-            this.resetCameraCPU(resetPan, resetZoom);
-        }
-        else {
-            this.resetCameraGPU(resetPan, resetZoom);
-        }
-        return true;
-    }
     resetCameraCPU(resetPan, resetZoom) {
         const { image } = this._cpuFallbackEnabledElement;
         if (!image) {
@@ -1318,53 +1360,15 @@ class StackViewport extends Viewport_1.default {
         }
         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();
+    _getVOIRangeForCurrentImage() {
+        const { windowCenter, windowWidth } = this.csImage;
+        return this._getVOIRangeFromWindowLevel(windowWidth, windowCenter);
     }
-    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');
+    _getValidVOILUTFunction(voiLUTFunction) {
+        if (Object.values(VOILUTFunctionType_1.default).indexOf(voiLUTFunction) === -1) {
+            voiLUTFunction = VOILUTFunctionType_1.default.LINEAR;
         }
-        return super.removeAllActors();
+        return voiLUTFunction;
     }
     getCPUFallbackError(method) {
         return new Error(`method ${method} cannot be used during CPU Fallback mode`);
@@ -1375,22 +1379,6 @@ class StackViewport extends Viewport_1.default {
             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 = {};