base.py

import numpy as np
import ast
import plotly.graph_objects as go
from scipy.signal import medfilt, detrend
from abc import ABCMeta, abstractmethod
from importlib import import_module
from ..signals.bvp import BVPsignal
from ..utils import filters, printutils
from ..utils import detrending

def methodFactory(methodName, *args, **kwargs):
    try:
        moduleName = methodName.lower()
        className = methodName.upper()
        methodModule = import_module('.methods.' + moduleName, package='pyVHR')
        classOBJ = getattr(methodModule, className)
        obj = classOBJ(**kwargs)

    except (AttributeError, ModuleNotFoundError):
        raise ImportError('{} is not part of pyVHR method collection!'.format(methodName))

    return obj
    
class VHRMethod(metaclass=ABCMeta):
    """
    Manage VHR approaches (parent class for new approach)
    """
    
    def __init__(self, **kwargs):
        self.video = kwargs['video']
        self.verb = kwargs['verb']
        
    @abstractmethod
    def apply(self, X):
        pass

    def runOffline(self, **kwargs):
        
        # -- parse params
        startTime, endTime, winSize, timeStep, zeroMeanSTDnorm, BPfilter, minHz, maxHz, detrFilter, \
        detrMethod, detrLambda = self.__readparams(**kwargs)
        
        fs = self.video.frameRate
        
        # -- check times
        if endTime > self.video.duration:
            endTime = self.video.duration
        assert startTime <= endTime, "Time interval error!"
        assert timeStep > 0, "Time step must be positive!"
        assert winSize < (endTime-startTime),"Winsize too big!"

        # -- verbose prints
        if '1' in str(self.verb):
            self.__verbose(startTime, endTime, winSize)
        
        if self.video.doEVM is True:
            self.video.applyEVM()
        else:
            self.video.processedFaces = self.video.faces

        timeSteps = np.arange(startTime,endTime,timeStep)
        T = startTime    # times where bpm are estimated
        RADIUS = winSize/2

        bpmES = []     # bmp estimtes
        timesES = []   # times of bmp estimtes

        # -- loop on video signal chunks
        startFrame = int(T*self.video.frameRate)
        count = 0
        while T <= endTime:
            endFrame = np.min([self.video.numFrames, int((T+RADIUS)*self.video.frameRate)])

            # -- extract ROIs on the frame range
            self.frameSubset = np.arange(startFrame, endFrame)

            self.ROImask = kwargs['ROImask']

            # -- type of signal extractor
            if self.ROImask == 'rect':
                rects = ast.literal_eval(kwargs['rectCoords'])
                self.rectCoords = []
                for x in rects:
                    rect = []
                    for y in x:
                        rect.append(int(y))
                    self.rectCoords.append(rect)
                self.video.setMask(self.ROImask, rectCoords=self.rectCoords)
            elif self.ROImask == 'skin_adapt':
                self.video.setMask(self.ROImask, skinThresh_adapt=float(kwargs['skinAdapt']))
            elif self.ROImask == 'skin_fix':
                threshs = ast.literal_eval(kwargs['skinFix'])
                self.threshSkinFix = [int(x) for x in threshs]
                self.video.setMask(self.ROImask, skinThresh_fix=self.threshSkinFix)
            else:
                raise ValueError(self.ROImask + " : Unimplemented Signal Extractor!")
                
            self.video.extractSignal(self.frameSubset, count)

            # -- RGB computation  
            RGBsig = self.video.getMeanRGB()
            
            # -- print RGB raw data
            if '2' in str(self.verb):
                printutils.multiplot(y=RGBsig, name=['ch B', 'ch R','ch G'], title='RGB raw data')
                        
            # -- RGBsig preprocessing
            if zeroMeanSTDnorm:
                RGBsig = filters.zeroMeanSTDnorm(RGBsig)      
            if detrFilter:
                if detrMethod == 'tarvainen':
                    #TODO controllare il detrending di tarvainen
                    RGBsig[0] = detrending.detrend(RGBsig[0], detrLambda)
                    RGBsig[1] = detrending.detrend(RGBsig[1], detrLambda)
                    RGBsig[2] = detrending.detrend(RGBsig[2], detrLambda)
                else:
                    RGBsig = detrend(RGBsig)
            if BPfilter:
                RGBsig = filters.BPfilter(RGBsig, minHz, maxHz, fs)
            
            # -- print postproce
            if '2' in str(self.verb):
                printutils.multiplot(y=RGBsig, name=['ch B', 'ch R','ch G'], title='RGB postprocessing')
            
            # -- apply the selected method to estimate BVP
            rPPG = self.apply(RGBsig)
                        
            # BVP postprocessing 
            startTime = np.max([0, T-winSize/self.video.frameRate])
            bvpChunk = BVPsignal(rPPG, self.video.frameRate, startTime, minHz, maxHz, self.verb)
            
            # -- post processing: filtering 
            
            # TODO: valutare se mantenere!!
            #bvpChunk.data = filters.BPfilter(bvpChunk.data, bvpChunk.minHz, bvpChunk.maxHz, bvpChunk.fs)

            if '2' in str(self.verb):
                bvpChunk.plot(title='BVP estimate by ' + self.methodName)
          
            # -- estimate BPM by PSD
            bvpChunk.PSD2BPM(chooseBest=True)

            # -- save the estimate
            bpmES.append(bvpChunk.bpm)
            timesES.append(T)

            # -- define the frame range for each time step            
            T += timeStep
            startFrame = np.max([0, int((T-RADIUS)*self.video.frameRate)])

            count += 1

        # set final values
        self.bpm = np.array(bpmES).T
        
        # TODO controllare se mettere o no il filtro seguente
        #self.bpm = self.bpm_time_filter(self.bpm, 3)
        self.times = np.array(timesES)
        
        return self.bpm, self.times

    @staticmethod    
    def makeMethodObject(video, methodName='ICA'):
        if methodName == 'CHROM':
            m = methods.CHROM(video)
        elif methodName == 'LGI':
            m = methods.LGI(video)
        elif methodName == 'SSR':
            m = methods.SSR(video)
        elif methodName == 'PBV':
            m = methods.PBV(video)
        elif methodName == 'POS':
            m = methods.POS(video)
        elif methodName == 'Green':
            m = methods.Green(video)
        elif methodName == 'PCA':
            m = methods.PCA(video)
        elif methodName == 'ICA':
            m = methods.ICA(video)
        else:
            raise ValueError("Unknown method!")
        return m

    def __readparams(self, **kwargs):
        
        # get params from kwargs or set default
        if 'startTime' in kwargs:
            startTime = float(kwargs['startTime'])
        else:
            startTime = 0
        if 'endTime' in kwargs:
            if kwargs['endTime']=='INF':
                endTime = np.Inf
            else:
                endTime = float(kwargs['endTime'])
        else:
            endTime=np.Inf
        if 'winSize' in kwargs:
            winSize = int(kwargs['winSize'])
        else:
            winSize = 5
        if 'timeStep' in kwargs:
            timeStep = float(kwargs['timeStep'])
        else:
            timeStep = 1
        if 'zeroMeanSTDnorm' in kwargs:
            zeroMeanSTDnorm = int(kwargs['zeroMeanSTDnorm'])
        else:
            zeroMeanSTDnorm = 0
        if 'BPfilter' in kwargs:
            BPfilter = int(kwargs['BPfilter'])
        else:
            BPfilter = 1
        if 'minHz' in kwargs:
            minHz = float(kwargs['minHz'])
        else:
            minHz = .75
        if 'maxHz' in kwargs:
            maxHz = float(kwargs['maxHz'])
        else:
            maxHz = 4.
        if 'detrending' in kwargs:
            detrending = int(kwargs['detrending'])
        else:
            detrending = 0
        if detrending:
            if 'detrLambda' in kwargs:
                detrLambda = kwargs['detrLambda']
            else:
                detrLambda = 10
        else:
            detrLambda = 10
        if 'detrMethod' in kwargs:
            detrMethod = kwargs['detrMethod']
        else:
            detrMethod = 'tarvainen'
            
        return startTime, endTime, winSize, timeStep, zeroMeanSTDnorm, BPfilter, minHz, maxHz,\
                detrending, detrMethod, detrLambda
    
    def RMSEerror(self, bvpGT):
        """ RMSE: """

        diff = self.__diff(bvpGT)
        n,m = diff.shape  # n = num channels, m = bpm length
        df = np.zeros(n)
        for j in range(m):
            for c in range(n):
                df[c] += np.power(diff[c,j],2)

        # -- final RMSE
        RMSE = np.sqrt(df/m)
        return RMSE

    def MAEerror(self, bvpGT):
        """ MAE: """

        diff = self.__diff(bvpGT)
        n,m = diff.shape  # n = num channels, m = bpm length
        df = np.sum(np.abs(diff),axis=1)

        # -- final MAE
        MAE = df/m
        return MAE

    def MAXError(self, bvpGT):
        """ MAE: """

        diff = self.__diff(bvpGT)
        n,m = diff.shape  # n = num channels, m = bpm length
        df = np.max(np.abs(diff),axis=1)

        # -- final MAE
        MAX = df
        return MAX

    def PearsonCorr(self, bvpGT):
        from scipy import stats

        diff = self.__diff(bvpGT)
        bpmES = self.bpm
        n,m = diff.shape  # n = num channels, m = bpm length
        CC = np.zeros(n)
        for c in range(n):
            # -- corr
            r,p = stats.pearsonr(diff[c,:]+bpmES[c,:],bpmES[c,:])
            CC[c] = r
        return CC

    def printErrors(self, bvpGT):
        RMSE = self.RMSEerror(bvpGT)
        MAE = self.MAEerror(bvpGT)
        CC = self.PearsonCorr(bvpGT)
        print('\nErrors:')
        print('        RMSE: ' + str(RMSE))
        print('        MAE : ' + str(MAE))
        print('        CC  : ' + str(CC))

    def displayError(self, bvpGT):
        bpmGT = bvpGT.bpm
        timesGT = bvpGT.times
        bpmES = self.bpm
        timesES = self.times
        diff = self.__diff(bvpGT)
        n,m = diff.shape  # n = num channels, m = bpm length
        df = np.abs(diff)
        dfMean = np.around(np.mean(df,axis=1),1)

        # -- plot errors
        fig = go.Figure()
        name = 'Ch 1 (µ = ' + str(dfMean[0])+ ' )'
        fig.add_trace(go.Scatter(x=timesES, y=df[0,:], name=name, mode='lines+markers'))
        if n > 1:
            name = 'Ch 2 (µ = ' + str(dfMean[1])+ ' )'
            fig.add_trace(go.Scatter(x=timesES, y=df[1,:], name=name, mode='lines+markers'))
            name = 'Ch 3 (µ = ' + str(dfMean[2])+ ' )'
            fig.add_trace(go.Scatter(x=timesES, y=df[2,:], name=name, mode='lines+markers'))
        fig.update_layout(xaxis_title='Times (sec)', yaxis_title='MAE', showlegend=True)
        fig.show()
        
        # -- plot bpm Gt and ES 
        fig = go.Figure()
        GTmean = np.around(np.mean(bpmGT),1)
        name = 'GT (µ = ' + str(GTmean)+ ' )'
        fig.add_trace(go.Scatter(x=timesGT, y=bpmGT, name=name, mode='lines+markers'))
        ESmean = np.around(np.mean(bpmES[0,:]),1)
        name = 'ES1 (µ = ' + str(ESmean)+ ' )'
        fig.add_trace(go.Scatter(x=timesES, y=bpmES[0,:], name=name, mode='lines+markers'))
        if n > 1:
            ESmean = np.around(np.mean(bpmES[1,:]),1)
            name = 'ES2 (µ = ' + str(ESmean)+ ' )'
            fig.add_trace(go.Scatter(x=timesES, y=bpmES[1,:], name=name, mode='lines+markers'))
            ESmean = np.around(np.mean(bpmES[2,:]),1)
            name = 'E3 (µ = ' + str(ESmean)+ ' )'
            fig.add_trace(go.Scatter(x=timesES, y=bpmES[2,:], name=name, mode='lines+markers'))
        
        
        
        fig.update_layout(xaxis_title='Times (sec)', yaxis_title='BPM', showlegend=True)
        fig.show()



    def __diff(self, bvpGT):
        bpmGT = bvpGT.bpm
        timesGT = bvpGT.times
        bpmES = self.bpm
        timesES = self.times
        n,m = bpmES.shape  # n = num channels, m = bpm length

        diff = np.zeros((n,m))
        for j in range(m):
            t = timesES[j]
            i = np.argmin(np.abs(t-timesGT))
            for c in range(n):
                diff[c,j] = bpmGT[i]-bpmES[c,j]
        return diff

    def bpm_time_filter(self, bpm, w_len):

        n_sig = bpm.shape[0]
        filtered_bpm = []
    
        for s in range(n_sig):
            x = bpm[s,:]
            x = medfilt(x, w_len)
            filtered_bpm.append(x)

        filtered_bpm = np.vstack(filtered_bpm)

        return filtered_bpm
    
        
    def __verbose(self, startTime, endTime, winSize):
        print("\n    * %s params: start time = %.1f, end time = %.1f, winsize = %.1f (sec)" 
              %(self.methodName, startTime, endTime, winSize))