@cornerstonejs/core 0.33.0 → 0.33.1

package/dist/esm/RenderingEngine/StackViewport.js

@@ -33,9 +33,9 @@ const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
         super(props);
+        this.voiUpdatedWithSetProperties = false;
         this.invert = false;
         this.stackInvalidated = false;
-        this.voiApplied = false;
         this._publishCalibratedEvent = false;
         this.resize = () => {
             if (this.useCPURendering) {
@@ -69,22 +69,16 @@ class StackViewport extends Viewport {
             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;
@@ -101,18 +95,6 @@ class StackViewport extends Viewport {
                 ? 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;
@@ -225,9 +207,98 @@ class StackViewport extends Viewport {
                 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 = getShouldUseCPURendering();
+        this._configureRenderingPipeline();
         if (this.useCPURendering) {
             this._cpuFallbackEnabledElement = {
                 canvas: this.canvas,
@@ -258,20 +329,21 @@ class StackViewport extends Viewport {
     static get useCustomRenderingPipeline() {
         return 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.addEventListener(Events.ELEMENT_DISABLED, function elementDisabledHandler() {
             clearTimeout(this.debouncedTimeout);
             eventTarget.removeEventListener(Events.ELEMENT_DISABLED, elementDisabledHandler);
         });
     }
-    getImageData() {
-        if (this.useCPURendering) {
-            return this.getImageDataCPU();
-        }
-        else {
-            return this.getImageDataGPU();
-        }
-    }
     getImageDataGPU() {
         const defaultActor = this.getDefaultActor();
         if (!defaultActor) {
@@ -332,28 +404,18 @@ class StackViewport extends Viewport {
             },
         };
     }
-    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).indexOf(voiLUTFunction) === -1) {
-                voiLUTFunction = VOILUTFunctionType.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);
@@ -369,8 +431,8 @@ class StackViewport extends Viewport {
                 pixelRepresentation,
                 windowWidth,
                 windowCenter,
-                voiLUTFunction,
                 modality,
+                voiLUTFunction: voiLUTFunctionEnum,
             },
         };
     }
@@ -418,8 +480,9 @@ class StackViewport extends Viewport {
         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);
@@ -438,6 +501,7 @@ class StackViewport extends Viewport {
     }
     resetProperties() {
         this.cpuRenderingInvalidated = true;
+        this.voiUpdatedWithSetProperties = false;
         this.fillWithBackgroundColor();
         if (this.useCPURendering) {
             this._cpuFallbackEnabledElement.renderingTools = {};
@@ -445,38 +509,36 @@ class StackViewport extends Viewport {
         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.LINEAR);
+        this.setInvertColor(false);
     }
-    setCamera(cameraInterface, storeAsInitialCamera = false) {
-        if (this.useCPURendering) {
-            this.setCameraCPU(cameraInterface);
+    _setPropertiesFromCache() {
+        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 = this._getVOIRangeForCurrentImage() ?? this.voiRange;
         }
-    }
-    _resetProperties() {
-        this.voiApplied = false;
-        this.setProperties({
-            voiRange: this.initialVOIRange,
-            rotation: 0,
-            interpolationType: InterpolationType.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;
@@ -563,21 +625,11 @@ class StackViewport extends Viewport {
             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,
@@ -593,26 +645,15 @@ class StackViewport extends Viewport {
         if (this.useCPURendering) {
             throw new Error('VOI LUT function is not supported in CPU rendering');
         }
-        if (Object.values(VOILUTFunctionType).indexOf(voiLUTFunction) === -1) {
-            voiLUTFunction = VOILUTFunctionType.LINEAR;
+        const newVOILUTFunction = this._getValidVOILUTFunction(voiLUTFunction);
+        let forceRecreateLUTFunction = false;
+        if (this.VOILUTFunction !== VOILUTFunctionType.LINEAR &&
+            newVOILUTFunction === VOILUTFunctionType.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;
@@ -643,12 +684,8 @@ class StackViewport extends Viewport {
     }
     setInterpolationTypeCPU(interpolationType) {
         const { viewport } = this._cpuFallbackEnabledElement;
-        if (interpolationType === InterpolationType.LINEAR) {
-            viewport.pixelReplication = false;
-        }
-        else {
-            viewport.pixelReplication = true;
-        }
+        viewport.pixelReplication =
+            interpolationType === InterpolationType.LINEAR ? false : true;
         this.interpolationType = interpolationType;
     }
     setInvertColorCPU(invert) {
@@ -684,7 +721,8 @@ class StackViewport extends Viewport {
             this.invert = invert;
         }
     }
-    setVOICPU(voiRange, suppressEvents) {
+    setVOICPU(voiRange, options = {}) {
+        const { suppressEvents = false } = options;
         const { viewport, image } = this._cpuFallbackEnabledElement;
         if (!viewport || !image) {
             return;
@@ -712,7 +750,6 @@ class StackViewport extends Viewport {
             viewport.voi.windowWidth = windowWidth;
             viewport.voi.windowCenter = windowCenter;
         }
-        this.voiApplied = true;
         this.voiRange = voiRange;
         const eventDetail = {
             viewportId: this.id,
@@ -722,7 +759,15 @@ class StackViewport extends Viewport {
             triggerEvent(this.element, Events.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;
@@ -730,8 +775,7 @@ class StackViewport extends Viewport {
         if (!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();
@@ -740,43 +784,48 @@ class StackViewport extends Viewport {
             voiRangeToUse = maxVoiRange;
         }
         imageActor.getProperty().setUseLookupTableScalarRange(true);
-        if (this.VOILUTFunction === VOILUTFunctionType.SAMPLED_SIGMOID) {
-            const cfun = createSigmoidRGBTransferFunction(voiRangeToUse);
+        let transferFunction = imageActor.getProperty().getRGBTransferFunction(0);
+        const isSigmoidTFun = this.VOILUTFunction === VOILUTFunctionType.SAMPLED_SIGMOID;
+        if (isSigmoidTFun || !transferFunction || forceRecreateLUTFunction) {
+            const transferFunctionCreator = isSigmoidTFun
+                ? createSigmoidRGBTransferFunction
+                : createLinearRGBTransferFunction;
+            transferFunction = transferFunctionCreator(voiRangeToUse);
             if (this.invert) {
-                invertRgbTransferFunction(cfun);
+                invertRgbTransferFunction(transferFunction);
             }
-            imageActor.getProperty().setRGBTransferFunction(0, cfun);
+            imageActor.getProperty().setRGBTransferFunction(0, transferFunction);
         }
-        else {
-            const cfun = createLinearRGBTransferFunction(voiRangeToUse);
-            if (this.invert) {
-                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,
-            };
-            triggerEvent(this.element, Events.VOI_MODIFIED, eventDetail);
+        if (!this.voiUpdatedWithSetProperties) {
+            this.voiUpdatedWithSetProperties = voiUpdatedWithSetProperties;
         }
+        if (suppressEvents) {
+            return;
+        }
+        const eventDetail = {
+            viewportId: this.id,
+            range: voiRangeToUse,
+            VOILUTFunction: this.VOILUTFunction,
+        };
+        triggerEvent(this.element, Events.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;
@@ -788,7 +837,7 @@ class StackViewport extends Viewport {
         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;
@@ -870,8 +919,9 @@ class StackViewport extends Viewport {
         this.stackInvalidated = true;
         this.flipVertical = false;
         this.flipHorizontal = false;
-        this.voiApplied = false;
-        this._resetProperties();
+        this.voiRange = null;
+        this.interpolationType = InterpolationType.LINEAR;
+        this.invert = false;
         this.fillWithBackgroundColor();
         if (this.useCPURendering) {
             this._cpuFallbackEnabledElement.renderingTools = {};
@@ -936,12 +986,9 @@ class StackViewport extends Viewport {
         this._imageData.modified();
     }
     async _loadAndDisplayImage(imageId, imageIdIndex) {
-        if (this.useCPURendering) {
-            await this._loadAndDisplayImageCPU(imageId, imageIdIndex);
-        }
-        else {
-            await this._loadAndDisplayImageGPU(imageId, imageIdIndex);
-        }
+        await (this.useCPURendering
+            ? this._loadAndDisplayImageCPU(imageId, imageIdIndex)
+            : this._loadAndDisplayImageGPU(imageId, imageIdIndex));
         return imageId;
     }
     _loadAndDisplayImageCPU(imageId, imageIdIndex) {
@@ -950,6 +997,7 @@ class StackViewport extends Viewport {
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
+                image.isPreScaled = image.preScale?.scaled;
                 this.csImage = image;
                 const eventDetail = {
                     image,
@@ -960,7 +1008,6 @@ class StackViewport extends Viewport {
                 };
                 triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
                 const metadata = this._getImageDataMetadata(image);
-                image.isPreScaled = image.preScale?.scaled;
                 const viewport = getDefaultViewport(this.canvas, image, this.modality, this._cpuFallbackEnabledElement.viewport.colormap);
                 this._cpuFallbackEnabledElement.image = image;
                 this._cpuFallbackEnabledElement.metadata = {
@@ -1020,6 +1067,7 @@ class StackViewport extends Viewport {
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
+                image.isPreScaled = image.preScale?.scaled;
                 this.csImage = image;
                 const eventDetail = {
                     image,
@@ -1117,41 +1165,43 @@ class StackViewport extends Viewport {
         this.resetCameraNoEvent();
         this.triggerCameraEvent(this.getCamera(), previousCameraProps);
         activeCamera.setFreezeFocalPoint(true);
-        const { windowCenter, windowWidth, voiLUTFunction } = imagePixelModule;
-        let voiRange = typeof windowCenter === 'number' && typeof windowWidth === 'number'
-            ? windowLevelUtil.toLowHighRange(windowWidth, windowCenter)
-            : undefined;
-        const isPreScaled = this.csImage.isPreScaled || this.csImage.preScale?.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).indexOf(voiLUTFunction) === -1) {
-            this.VOILUTFunction = VOILUTFunctionType.LINEAR;
-        }
-        else {
-            this.VOILUTFunction = voiLUTFunction;
-        }
-        this.setProperties({ voiRange });
-        if (actor.getProperty().getRGBTransferFunction(0) === null) {
-            const cfun = createLinearRGBTransferFunction(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'
+            ? windowLevelUtil.toLowHighRange(windowWidth, windowCenter)
+            : undefined;
+    }
     async _setImageIdIndex(imageIdIndex) {
         if (imageIdIndex >= this.imageIds.length) {
             throw new Error(`ImageIdIndex provided ${imageIdIndex} is invalid, the stack only has ${this.imageIds.length} elements`);
@@ -1161,15 +1211,6 @@ class StackViewport extends Viewport {
         const imageId = await this._loadAndDisplayImage(this.imageIds[imageIdIndex], imageIdIndex);
         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) {
@@ -1285,53 +1326,15 @@ class StackViewport extends Viewport {
         }
         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).indexOf(voiLUTFunction) === -1) {
+            voiLUTFunction = VOILUTFunctionType.LINEAR;
         }
-        return super.removeAllActors();
+        return voiLUTFunction;
     }
     getCPUFallbackError(method) {
         return new Error(`method ${method} cannot be used during CPU Fallback mode`);
@@ -1342,22 +1345,6 @@ class StackViewport extends Viewport {
             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 = {};