Upload 45 files

.gitattributes

@@ -53,3 +53,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+shape_predictor_5_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text
+shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text

FaceAligner.py

@@ -0,0 +1,58 @@
+import numpy as np
+import cv2
+
+class FaceAligner:
+    def __init__(self, desiredLeftEye=(0.35, 0.35),
+        desiredFaceWidth=256, desiredFaceHeight=None):
+        # store the facial landmark predictor, desired output left
+        # eye position, and desired output face width + height
+        self.desiredLeftEye = desiredLeftEye
+        self.desiredFaceWidth = desiredFaceWidth
+        self.desiredFaceHeight = desiredFaceHeight
+
+        # if the desired face height is None, set it to be the
+        # desired face width (normal behavior)
+        if self.desiredFaceHeight is None:
+            self.desiredFaceHeight = self.desiredFaceWidth
+
+    def align(self, image, r_eye, l_eye):
+        leftEyeCenter = np.array(l_eye)
+        rightEyeCenter = np.array(r_eye)
+
+        # compute the angle between the eye centroids
+        dY = rightEyeCenter[1] - leftEyeCenter[1]
+        dX = rightEyeCenter[0] - leftEyeCenter[0]
+        angle = np.degrees(np.arctan2(dY, dX))# - 180
+
+        # compute the desired right eye x-coordinate based on the
+        # desired x-coordinate of the left eye
+        desiredRightEyeX = 1.0 - self.desiredLeftEye[0]
+
+        # determine the scale of the new resulting image by taking
+        # the ratio of the distance between eyes in the *current*
+        # image to the ratio of distance between eyes in the
+        # *desired* image
+        dist = np.sqrt((dX ** 2) + (dY ** 2))
+        desiredDist = (desiredRightEyeX - self.desiredLeftEye[0])
+        desiredDist *= self.desiredFaceWidth
+        scale = desiredDist / dist
+
+        # compute center (x, y)-coordinates (i.e., the median point)
+        # between the two eyes in the input image
+        eyesCenter = ((leftEyeCenter[0] + rightEyeCenter[0]) // 2,(leftEyeCenter[1] + rightEyeCenter[1]) // 2)
+
+        # grab the rotation matrix for rotating and scaling the face
+        M = cv2.getRotationMatrix2D(eyesCenter, angle, scale)
+
+        # update the translation component of the matrix
+        tX = self.desiredFaceWidth * 0.5
+        tY = self.desiredFaceHeight * self.desiredLeftEye[1]
+        M[0, 2] += (tX - eyesCenter[0])
+        M[1, 2] += (tY - eyesCenter[1])
+
+        # apply the affine transformation
+        (w, h) = (self.desiredFaceWidth, self.desiredFaceHeight)
+        output = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC)
+
+        # return the aligned face
+        return output

HDI.py

@@ -0,0 +1,119 @@
+from __future__ import division
+import numpy as np
+import scipy.stats.kde as kde
+
+def calc_min_interval(x, alpha):
+    """Internal method to determine the minimum interval of a given width
+    Assumes that x is sorted numpy array.
+    """
+
+    n = len(x)
+    cred_mass = 1.0-alpha
+
+    interval_idx_inc = int(np.floor(cred_mass*n))
+    n_intervals = n - interval_idx_inc
+    interval_width = x[interval_idx_inc:] - x[:n_intervals]
+
+    if len(interval_width) == 0:
+        raise ValueError('Too few elements for interval calculation')
+
+    min_idx = np.argmin(interval_width)
+    hdi_min = x[min_idx]
+    hdi_max = x[min_idx+interval_idx_inc]
+    return hdi_min, hdi_max
+
+
+def hdi(x, alpha=0.05):
+    """Calculate highest posterior density (HPD) of array for given alpha. 
+    The HPD is the minimum width Bayesian credible interval (BCI).
+    :Arguments:
+        x : Numpy array
+        An array containing MCMC samples
+        alpha : float
+        Desired probability of type I error (defaults to 0.05)
+    """
+
+    # Make a copy of trace
+    x = x.copy()
+    # For multivariate node
+    if x.ndim > 1:
+        # Transpose first, then sort
+        tx = np.transpose(x, list(range(x.ndim))[1:]+[0])
+        dims = np.shape(tx)
+        # Container list for intervals
+        intervals = np.resize(0.0, dims[:-1]+(2,))
+
+        for index in make_indices(dims[:-1]):
+            try:
+                index = tuple(index)
+            except TypeError:
+                pass
+
+            # Sort trace
+            sx = np.sort(tx[index])
+            # Append to list
+            intervals[index] = calc_min_interval(sx, alpha)
+        # Transpose back before returning
+        return np.array(intervals)
+    else:
+        # Sort univariate node
+        sx = np.sort(x)
+        return np.array(calc_min_interval(sx, alpha))
+
+
+def hdi2(sample, alpha=0.05, roundto=2):
+    """Calculate highest posterior density (HPD) of array for given alpha. 
+    The HPD is the minimum width Bayesian credible interval (BCI). 
+    The function works for multimodal distributions, returning more than one mode
+    Parameters
+    ----------
+    
+    sample : Numpy array or python list
+        An array containing MCMC samples
+    alpha : float
+        Desired probability of type I error (defaults to 0.05)
+    roundto: integer
+        Number of digits after the decimal point for the results
+    Returns
+    ----------
+    hpd: array with the lower 
+          
+    """
+    sample = np.asarray(sample)
+    sample = sample[~np.isnan(sample)]
+    # get upper and lower bounds
+    l = np.min(sample)
+    u = np.max(sample)
+    density = kde.gaussian_kde(sample)
+    x = np.linspace(l, u, 2000)
+    y = density.evaluate(x)
+    #y = density.evaluate(x, l, u) waitting for PR to be accepted
+    xy_zipped = zip(x, y/np.sum(y))
+    xy = sorted(xy_zipped, key=lambda x: x[1], reverse=True)
+    xy_cum_sum = 0
+    hdv = []
+
+    for val in xy:
+        xy_cum_sum += val[1]
+        hdv.append(val[0])
+        if xy_cum_sum >= (1-alpha):
+            break
+    hdv.sort()
+    diff = (u-l)/20  # differences of 5%
+    hpd = []
+    hpd.append(round(min(hdv), roundto))
+
+    for i in range(1, len(hdv)):
+        if hdv[i]-hdv[i-1] >= diff:
+            hpd.append(round(hdv[i-1], roundto))
+            hpd.append(round(hdv[i], roundto))
+    hpd.append(round(max(hdv), roundto))
+    ite = iter(hpd)
+    hpd = list(zip(ite, ite))
+    modes = []
+    for value in hpd:
+         x_hpd = x[(x > value[0]) & (x < value[1])]
+         y_hpd = y[(x > value[0]) & (x < value[1])]
+
+         modes.append(round(x_hpd[np.argmax(y_hpd)], roundto))
+    return hpd, x, y, modes

SkinColorFilter.py

@@ -0,0 +1,226 @@
+# BSD 3-Clause “New” or “Revised” License
+#
+# Copyright (c) 2016 Idiap Research Institute, http://www.idiap.ch/
+# Written by Guillaume Heusch <guillaume.heusch@idiap.ch>
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+# 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+# Original authors:
+# Guillaume HEUSCH <guillaume.heusch@idiap.ch> 29/07/2015
+#
+# Contributors:
+# Michele Maione <mikymaione@hotmail.it> 07/03/2019
+
+import numpy
+
+
+class SkinColorFilter():
+    """
+    This class implements a number of functions to perform skin color filtering.
+    It is based on the work published in "Adaptive skin segmentation via feature-based face detection",
+    M.J. Taylor and T. Morris, Proc SPIE Photonics Europe, 2014 [taylor-spie-2014]_
+    Attributes
+    ----------
+    mean: numpy.ndarray | dim: 2
+        the mean skin color
+    covariance: numpy.ndarray | dim: 2x2
+        the covariance matrix of the skin color
+    covariance_inverse: numpy.ndarray | dim: 2x2
+        the inverse covariance matrix of the skin color
+    circular_mask: numpy.ndarray
+        mask of the size of the image, defining a circular region in the center
+    luma_mask: numpy.ndarray
+        mask of the size of the image, defining valid luma values
+    """
+
+    def __init__(self):
+        self.mean = numpy.array([0.0, 0.0])
+        self.covariance = numpy.zeros((2, 2), 'float64')
+        self.covariance_inverse = numpy.zeros((2, 2), 'float64')
+
+    def __generate_circular_mask(self, image, radius_ratio=0.4):
+
+        w = image.shape[0]
+        h = image.shape[1]
+        radius = radius_ratio * h
+
+        x_center = h / 2
+        y_center = w / 2
+
+        center = [int(x_center), int(y_center)]
+    
+        Y, X = numpy.ogrid[:w, :h]
+        dist_from_center = numpy.sqrt((X - center[0])**2 + (Y-center[1])**2)
+
+        mask = dist_from_center <= radius
+
+        self.circular_mask = mask
+
+    '''def __generate_circular_mask(self, image, radius_ratio=0.4):
+        """
+        This function will generate a circular mask to be applied to the image.
+        The mask will be true for the pixels contained in a circle centered in the image center, and with radius equals to radius_ratio * the image's height.
+        Parameters
+        ----------
+        image: numpy.ndarray
+            The face image.
+        radius_ratio: float:
+            The ratio of the image's height to define the radius of the circular region. Defaults to 0.4.
+        """
+        w = image.shape[0]
+        h = image.shape[1]
+
+        x_center = w / 2
+        y_center = h / 2
+
+        # arrays with the image coordinates
+        X = numpy.zeros((w, h))
+
+        import code
+        code.interact(local=locals())
+
+        X[:] = range(0, w)
+
+        Y = numpy.zeros((h, w))
+        Y[:] = range(0, h)
+        Y = numpy.transpose(Y)
+
+        # translate s.t. the center is the origin
+        X -= x_center
+        Y -= y_center
+
+        # condition to be inside of a circle: x^2 + y^2 < r^2
+        radius = radius_ratio * h
+
+        # x ^ 2 + y ^ 2 < r ^ 2
+        cm = (X ** 2 + Y ** 2) < (radius ** 2)  # dim : w x h
+        self.circular_mask = cm'''
+
+    def __remove_luma(self, image):
+        """
+        This function remove pixels with extreme luma values.
+        Some pixels are considered as non-skin if their intensity is either too high or too low.
+        The luma value for all pixels inside a provided circular mask is calculated. Pixels for which the luma value deviates more than 1.5 * standard deviation are pruned.
+        Parameters
+        ----------
+        image: numpy.ndarray
+            The face image.
+        """
+
+        # compute the mean and std of luma values on non-masked pixels only
+        R = 0.299 * image[self.circular_mask, 0]
+        G = 0.587 * image[self.circular_mask, 1]
+        B = 0.114 * image[self.circular_mask, 2]
+
+        luma = R + G + B
+
+        m = numpy.mean(luma)
+        s = numpy.std(luma)
+
+        # apply the filtering to the whole image to get the luma mask
+        R = 0.299 * image[:, :, 0]
+        G = 0.587 * image[:, :, 1]
+        B = 0.114 * image[:, :, 2]
+
+        luma = R + G + B
+
+        # dim : image.x x image.y
+        lm = numpy.logical_and((luma > (m - 1.5 * s)), (luma < (m + 1.5 * s)))
+        self.luma_mask = lm
+
+    def __RG_Mask(self, image, dtype=None):
+        # dim: image.x x image.y
+        channel_sum = image[:, :, 0].astype('float64') + image[:, :, 1] + image[:, :, 2]
+
+        # dim: image.x x image.y
+        nonzero_mask = numpy.logical_or(numpy.logical_or(image[:, :, 0] > 0, image[:, :, 1] > 0), image[:, :, 2] > 0)
+
+        # dim: image.x x image.y
+        R = numpy.zeros((image.shape[0], image.shape[1]), dtype)
+        R[nonzero_mask] = image[nonzero_mask, 0] / channel_sum[nonzero_mask]
+
+        # dim: image.x x image.y
+        G = numpy.zeros((image.shape[0], image.shape[1]), dtype)
+        G[nonzero_mask] = image[nonzero_mask, 1] / channel_sum[nonzero_mask]
+
+        return R, G
+
+    def estimate_gaussian_parameters(self, image):
+        """
+        This function estimates the parameter of the skin color distribution.
+        The mean and covariance matrix of the skin pixels in the normalised rg colorspace are computed.
+        Note that only the pixels for which both the circular and the luma mask is 'True' are considered.
+        Parameters
+        ----------
+        image: numpy.ndarray
+            The face image.
+        """
+        self.__generate_circular_mask(image)
+        self.__remove_luma(image)
+
+        # dim: image.x x image.y
+        mask = numpy.logical_and(self.luma_mask, self.circular_mask)
+
+        # get the mean
+        # R dim: image.x x image.y
+        # G dim: image.x x image.y
+        R, G = self.__RG_Mask(image)
+
+        # dim: 2
+        self.mean = numpy.array([numpy.mean(R[mask]), numpy.mean(G[mask])])
+
+        # get the covariance
+        R_minus_mean = R[mask] - self.mean[0]
+        G_minus_mean = G[mask] - self.mean[1]
+
+        samples = numpy.vstack((R_minus_mean, G_minus_mean))
+        samples = samples.T
+
+        cov = sum([numpy.outer(s, s) for s in samples])  # dim: 2x2
+
+        self.covariance = cov / float(samples.shape[0] - 1)
+
+        # store the inverse covariance matrix (no need to recompute)
+        if numpy.linalg.det(self.covariance) != 0:
+            self.covariance_inverse = numpy.linalg.inv(self.covariance)
+        else:
+            self.covariance_inverse = numpy.zeros_like(self.covariance)
+
+    def get_skin_mask(self, image, threshold=0.5):
+        """
+        This function computes the probability of skin-color for each pixel in the image.
+        Parameters
+        ----------
+        image: numpy.ndarray
+            The face image.
+        threshold: float: 0->1
+            The threshold on the skin color probability. Defaults to 0.5
+        Returns
+        -------
+        skin_mask: numpy.ndarray
+            The mask where skin color pixels are labeled as True.
+        """
+
+        # get the image in rg colorspace
+        R, G = self.__RG_Mask(image, 'float64')
+
+        # compute the skin probability map
+        R_minus_mean = R - self.mean[0]
+        G_minus_mean = G - self.mean[1]
+
+        n = R.shape[0] * R.shape[1]
+        V = numpy.dstack((R_minus_mean, G_minus_mean))  # dim: image.x x image.y
+        V = V.reshape((n, 2))  # dim: nx2
+
+        probs = [numpy.dot(k, numpy.dot(self.covariance_inverse, k)) for k in V]
+        probs = numpy.array(probs).reshape(R.shape)  # dim: image.x x image.y
+
+        skin_map = numpy.exp(-0.5 * probs)  # dim: image.x x image.y
+
+        return skin_map > threshold

SkinDetect.py

@@ -0,0 +1,120 @@
+import numpy as np
+from scipy import signal
+import sys
+import cv2
+from pyVHR.utils.HDI import hdi, hdi2
+
+class SkinDetect():
+
+    def __init__(self, strength=0.2):
+        self.description = 'Skin Detection Module'
+        self.strength = strength
+        self.stats_computed = False
+
+    def compute_stats(self, face):
+
+        assert (self.strength > 0 and self.strength < 1), "'strength' parameter must have values in [0,1]"
+
+        faceColor = cv2.cvtColor(face, cv2.COLOR_RGB2HSV)
+        h = faceColor[:,:,0].reshape(-1,1)
+        s = faceColor[:,:,1].reshape(-1,1)
+        v = faceColor[:,:,2].reshape(-1,1)
+       
+        alpha = self.strength    #the highest, the stronger the masking  
+
+        hpd_h, x_h, y_h, modes_h = hdi2(np.squeeze(h), alpha=alpha)
+        min_s, max_s = hdi(np.squeeze(s), alpha=alpha)
+        min_v, max_v = hdi(np.squeeze(v), alpha=alpha)
+
+        if len(hpd_h) > 1:
+
+            self.multiple_modes = True
+
+            if len(hpd_h) > 2:
+                print('WARNING!! Found more than 2 HDIs in Hue Channel empirical Distribution... Considering only 2')
+                from scipy.spatial.distance import pdist, squareform
+                m = np.array(modes_h).reshape(-1,1)
+                d = squareform(pdist(m))
+                maxij = np.where(d==d.max())[0]
+                i = maxij[0]
+                j = maxij[1]
+            else:
+                i = 0
+                j = 1
+
+            min_h1 = hpd_h[i][0]
+            max_h1 = hpd_h[i][1]
+            min_h2 = hpd_h[j][0]
+            max_h2 = hpd_h[j][1]
+            
+            self.lower1 = np.array([min_h1, min_s, min_v], dtype = "uint8")
+            self.upper1 = np.array([max_h1, max_s, max_v], dtype = "uint8")
+            self.lower2 = np.array([min_h2, min_s, min_v], dtype = "uint8")
+            self.upper2 = np.array([max_h2, max_s, max_v], dtype = "uint8")
+
+        elif len(hpd_h) == 1:
+
+            self.multiple_modes = False
+            
+            min_h = hpd_h[0][0]
+            max_h = hpd_h[0][1]
+            
+            self.lower = np.array([min_h, min_s, min_v], dtype = "uint8")
+            self.upper = np.array([max_h, max_s, max_v], dtype = "uint8")
+
+        self.stats_computed = True
+
+
+    def get_skin(self, face, filt_kern_size=7, verbose=False, plot=False):
+
+        if not self.stats_computed:
+            raise ValueError("ERROR! You must compute stats at least one time")
+
+        faceColor = cv2.cvtColor(face, cv2.COLOR_RGB2HSV)
+
+        if self.multiple_modes:
+            if verbose:
+                print('\nLower1: ' + str(self.lower1))
+                print('Upper1: ' + str(self.upper1))
+                print('\nLower2: ' + str(self.lower2))
+                print('Upper2: ' + str(self.upper2) + '\n')
+
+            skinMask1 = cv2.inRange(faceColor, self.lower1, self.upper1)
+            skinMask2 = cv2.inRange(faceColor, self.lower2, self.upper2)
+            skinMask = np.logical_or(skinMask1, skinMask2).astype(np.uint8)*255
+
+        else:
+
+            if verbose:
+                print('\nLower: ' + str(lower))
+                print('Upper: ' + str(upper) + '\n')
+
+            skinMask = cv2.inRange(faceColor, self.lower, self.upper)
+
+        if filt_kern_size > 0:
+            skinMask = signal.medfilt2d(skinMask, kernel_size=filt_kern_size)
+        skinFace = cv2.bitwise_and(face, face, mask=skinMask)
+
+        if plot:
+            
+            h = faceColor[:,:,0].reshape(-1,1)
+            s = faceColor[:,:,1].reshape(-1,1)
+            v = faceColor[:,:,2].reshape(-1,1)
+
+            import matplotlib.pyplot as plt
+            plt.figure()              
+            plt.subplot(2,2,1)               
+            plt.hist(h, 20)
+            plt.title('Hue')
+            plt.subplot(2,2,2)
+            plt.hist(s, 20)
+            plt.title('Saturation')
+            plt.subplot(2,2,3)
+            plt.hist(v, 20)
+            plt.title('Value')
+            plt.subplot(2,2,4)
+            plt.imshow(skinFace)
+            plt.title('Masked Face')
+            plt.show()
+
+        return skinFace

__init__.py

@@ -0,0 +1 @@
+# __iniy__py

base.py

@@ -0,0 +1,377 @@
+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))
+        

bvp.py

@@ -0,0 +1,344 @@
+import numpy as np
+from scipy.signal import find_peaks, stft, lfilter, butter, welch
+from plotly.subplots import make_subplots
+from plotly.colors import n_colors
+import plotly.graph_objects as go
+from scipy.interpolate import interp1d
+
+
+class BVPsignal:
+    """
+        Manage (multi-channel, row-wise) BVP signals
+    """
+    nFFT = 2048  # freq. resolution for STFTs
+    step = 1       # step in seconds
+
+    def __init__(self, data, fs, startTime=0, minHz=0.75, maxHz=4., verb=False):
+        if len(data.shape) == 1:
+            self.data = data.reshape(1,-1) # 2D array raw-wise
+        else:
+            self.data = data
+        self.numChls = self.data.shape[0]  # num  channels
+        self.fs = fs                       # sample rate
+        self.startTime = startTime
+        self.verb = verb
+        self.minHz = minHz
+        self.maxHz = maxHz
+
+    def getChunk(startTime, winsize=None, numSample=None):
+        
+        assert startTime >= self.startTime, "Start time error!"
+        
+        N = self.data.shape[1] 
+        fs = self.fs
+        Nstart = int(fs*startTime)
+        
+        # -- winsize > 0
+        if winsize:
+            stopTime = startTime + winsize
+            Nstop = np.min([int(fs*stopTime),N])
+            
+        # -- numSample > 0
+        if numSample:
+            Nstop = np.min([numSample,N])
+        
+        return self.data[0,Nstart:Nstop]
+        
+    def hps(self, spect, d=3):
+        
+        if spect.ndim == 2:
+            n_win = spect.shape[1]
+            new_spect = np.zeros_like(spect)
+            for w in range(n_win):
+                curr_w = spect[:,w]
+                w_down_z = np.zeros_like(curr_w)
+                w_down = curr_w[::d]
+                w_down_z[0:len(w_down)] = w_down
+                w_hps = np.multiply(curr_w, w_down_z)
+                new_spect[:, w] = w_hps
+            return new_spect
+
+        elif spect.ndim == 1:
+            s_down_z = np.zeros_like(spect)
+            s_down = spect[::d]
+            s_down_z[0:len(s_down)] = s_down
+            w_hps = np.multiply(spect, s_down_z)
+            return w_hps
+
+        else:
+            raise ValueError("Wrong Dimensionality of the Spectrogram for the HPS")
+
+    def spectrogram(self, winsize=5, use_hps=False):
+        """
+        Compute the BVP signal spectrogram restricted to the
+        band 42-240 BPM by using winsize (in sec) samples.
+        """
+
+        # -- spect. Z is 3-dim: Z[#chnls, #freqs, #times]
+        F, T, Z = stft(self.data,
+                       self.fs,
+                       nperseg=self.fs*winsize,
+                       noverlap=self.fs*(winsize-self.step),
+                       boundary='even',
+                       nfft=self.nFFT)
+        Z = np.squeeze(Z, axis=0)
+
+        # -- freq subband (0.75 Hz - 4.0 Hz)
+        minHz = 0.75
+        maxHz = 4.0
+        band = np.argwhere((F > minHz) & (F < maxHz)).flatten()
+        self.spect = np.abs(Z[band,:])     # spectrum magnitude
+        self.freqs = 60*F[band]            # spectrum freq in bpm
+        self.times = T                     # spectrum times
+
+        if use_hps:
+            spect_hps = self.hps(self.spect)
+            # -- BPM estimate by spectrum
+            self.bpm = self.freqs[np.argmax(spect_hps,axis=0)]
+        else:
+            # -- BPM estimate by spectrum
+            self.bpm = self.freqs[np.argmax(self.spect,axis=0)]
+        
+    def getBPM(self, winsize=5):
+        self.spectrogram(winsize, use_hps=False)
+        return self.bpm, self.times
+    
+    def PSD2BPM(self, chooseBest=True, use_hps=False):
+        """
+            Compute power spectral density using Welch’s method and estimate
+            BPMs from video frames
+        """
+
+        # -- interpolation for less than 256 samples
+        c,n = self.data.shape
+        if n < 256:
+            seglength = n
+            overlap = int(0.8*n)  # fixed overlapping
+        else:
+            seglength = 256
+            overlap = 200
+       
+        # -- periodogram by Welch
+        F, P = welch(self.data, nperseg=seglength, noverlap=overlap, window='hamming',fs=self.fs, nfft=self.nFFT)
+
+        # -- freq subband (0.75 Hz - 4.0 Hz)
+        band = np.argwhere((F > self.minHz) & (F < self.maxHz)).flatten()
+        self.Pfreqs = 60*F[band]
+        self.Power = P[:,band]
+        
+        # -- if c = 3 choose that with the best SNR
+        if chooseBest:
+            winner = 0
+            lobes = self.PDSrippleAnalysis(ch=0)
+            SNR = lobes[-1]/lobes[-2]
+            if c == 3:
+                lobes = self.PDSrippleAnalysis(ch=1)
+                SNR1 = lobes[-1]/lobes[-2]
+                if SNR1 > SNR:
+                    SNR = SNR1
+                    winner = 1
+                lobes = self.PDSrippleAnalysis(ch=2)
+                SNR1 = lobes[-1]/lobes[-2]
+                if SNR1 > SNR:
+                    SNR = SNR1
+                    winner = 2    
+            self.Power = self.Power[winner].reshape(1,-1)
+        
+        # TODO: eliminare?
+        if use_hps:
+            p = self.Power[0]
+            phps = self.hps(p)
+            '''import matplotlib.pyplot as plt
+            plt.plot(p)
+            plt.figure()
+            plt.plot(phps)
+            plt.show()'''
+            Pmax = np.argmax(phps)  # power max
+            self.bpm = np.array([self.Pfreqs[Pmax]])       # freq max
+
+        else:
+            # -- BPM estimate by PSD
+            Pmax = np.argmax(self.Power, axis=1)  # power max
+            self.bpm = self.Pfreqs[Pmax]       # freq max
+
+        if '3' in str(self.verb):
+            lobes = self.PDSrippleAnalysis()
+            self.displayPSD(lobe1=lobes[-1], lobe2=lobes[-2])
+
+    def autocorr(self):
+        from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
+
+        # TODO: to handle all channels
+        x = self.data[0,:]
+        plot_acf(x)
+        plt.show()
+
+        plot_pacf(x)
+        plt.show()
+
+    def displaySpectrum(self, display=False, dims=3):
+        """Show the spectrogram of the BVP signal"""
+
+        # -- check if bpm exists
+        try:
+            bpm = self.bpm
+        except AttributeError:
+            self.spectrogram()
+            bpm = self.bpm
+            
+        t = self.times
+        f = self.freqs
+        S = self.spect
+
+        fig = go.Figure()
+        fig.add_trace(go.Heatmap(z=S, x=t, y=f, colorscale="viridis"))
+        fig.add_trace(go.Scatter(x=t, y=bpm, name='Frequency Domain', line=dict(color='red', width=2)))
+
+        fig.update_layout(autosize=False, height=420, showlegend=True,
+                          title='Spectrogram of the BVP signal',
+                          xaxis_title='Time (sec)',
+                          yaxis_title='BPM (60*Hz)',
+                          legend=dict(
+                            x=0,
+                            y=1,
+                            traceorder="normal",
+                            font=dict(
+                                family="sans-serif",
+                                size=12,
+                                color="black"),
+                            bgcolor="LightSteelBlue",
+                            bordercolor="Black",
+                            borderwidth=2)
+                         )
+                       
+        fig.show()
+
+    def findPeaks(self, distance=None, height=None):
+        
+        # -- take the first channel
+        x = self.data[0].flatten()
+            
+        if distance is None:
+            distance = self.fs/2
+        if height is None:
+            height = np.mean(x)
+
+        # -- find peaks with the specified params
+        self.peaks, _ = find_peaks(x, distance=distance, height=height)
+        
+        self.peaksTimes = self.peaks/self.fs
+        self.bpmPEAKS = 60.0/np.diff(self.peaksTimes)
+        
+    def plotBPMPeaks(self, height=None, width=None):
+        """
+            Plot the the BVP signal and peak marks
+        """
+
+        # -- find peaks  
+        try:
+            peaks = self.peaks
+        except AttributeError:
+            self.findPeaks()
+            peaks = self.peaks
+        
+        #-- signals 
+        y = self.data[0]
+        n = y.shape[0]
+        startTime  = self.startTime 
+        stopTime = startTime+n/self.fs
+        x = np.linspace(startTime, stopTime, num=n, endpoint=False)
+        
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=x, y=y, name="BVP"))
+        fig.add_trace(go.Scatter(x=x[peaks], y=y[peaks], mode='markers', name="Peaks"))
+
+        if not height:
+            height=400
+        if not width:
+            width=800
+
+        fig.update_layout(height=height, width=width, title="BVP signal + peaks",
+            font=dict(
+                family="Courier New, monospace",
+                size=14,
+                color="#7f7f7f"))
+        
+        fig.show()
+        
+    def plot(self, title="BVP signal", height=400, width=800):
+        """
+            Plot the the BVP signal (multiple channels)
+        """
+      
+        #-- signals 
+        y = self.data
+        c,n = y.shape
+        startTime  = self.startTime 
+        stopTime = startTime+n/self.fs
+        x = np.linspace(startTime, stopTime, num=n, endpoint=False)
+        
+        fig = go.Figure()
+        
+        for i in range(c):
+            name = "BVP " + str(i)
+            fig.add_trace(go.Scatter(x=x, y=y[i], name=name))
+
+        fig.update_layout(height=height, width=width, title=title,
+            font=dict(
+                family="Courier New, monospace",
+                size=14,
+                color="#7f7f7f"))
+        fig.show()
+        
+    def displayPSD(self, ch=0, lobe1=None, lobe2=None, GT=None):
+        """Show the periodogram(s) of the BVP signal for channel ch"""
+
+        f = self.Pfreqs 
+        P = self.Power[ch] 
+                
+        fig = go.Figure()
+        
+        fig.add_trace(go.Scatter(x=f, y=P, name='PSD'))
+        fig.update_layout(autosize=False, width=500, height=400)
+        
+        if lobe1 is not None and lobe2 is not None:
+            L1 = lobe1
+            L2 = lobe2
+            # Add horiz. lobe peack lines
+            fig.add_shape(type="line",x0=f[0], y0=L1, x1=f[-1], y1=L1,
+                line=dict(color="LightSeaGreen", width=2, dash="dashdot"))
+            fig.add_shape(type="line",x0=f[0], y0=L2, x1=f[-1], y1=L2,
+                line=dict(color="SeaGreen", width=2, dash="dashdot"))
+            tit = 'SNR = ' + str(np.round(L1/L2,2))
+            fig.update_layout(title=tit)
+            
+        if GT is not None:
+            # Add vertical GT line
+            fig.add_shape(type="line",x0=GT, y0=0, x1=GT, y1=np.max(P),
+                line=dict(color="DarkGray", width=2, dash="dash"))
+            
+        fig.show()
+  
+    def PDSrippleAnalysis(self, ch=0):
+        # -- ripple analysis
+        
+        P = self.Power[ch].flatten()
+        dP = np.gradient(P)
+        n = len(dP)
+        I = []; 
+        i = 0
+        while i < n:
+            m = 0
+            # -- positive gradient
+            while (i < n) and (dP[i] > 0):
+                m = max([m,P[i]])
+                i += 1
+            I.append(m)
+            # -- skip negative gradient
+            while (i < n) and (dP[i] < 0) : 
+                i += 1
+        lobes = np.sort(I)
+        if len(lobes) < 2:
+            lobes = np.array([lobes,0])
+            
+        return lobes

chrom.py

@@ -0,0 +1,33 @@
+from scipy import signal
+import numpy as np
+from .base import VHRMethod
+
+class CHROM(VHRMethod):
+    """ This method is described in the following paper:
+        "Remote heart rate variability for emotional state monitoring"
+        by Y. Benezeth, P. Li, R. Macwan, K. Nakamura, R. Gomez, F. Yang
+    """
+    methodName = 'CHROM'
+    
+    def __init__(self, **kwargs):
+        super(CHROM, self).__init__(**kwargs)
+        
+    def apply(self, X):
+
+        #self.RGB = self.getMeanRGB()
+        #X = signal.detrend(self.RGB.T)
+        
+        # calculation of new X and Y
+        Xcomp = 3*X[0] - 2*X[1]
+        Ycomp = (1.5*X[0])+X[1]-(1.5*X[2])
+
+        # standard deviations
+        sX = np.std(Xcomp)
+        sY = np.std(Ycomp)
+
+        alpha = sX/sY
+
+        # -- rPPG signal
+        bvp = Xcomp-alpha*Ycomp
+
+        return bvp

cohface.py

@@ -0,0 +1,47 @@
+import h5py
+import numpy as np
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class COHFACE(Dataset):
+    """
+    Cohface dataset structure:
+    -----------------
+        datasetDIR/
+        |
+        |-- subjDIR_1/
+        |   |-- vidDIR1/
+        |       |-- videoFile1.avi
+        |       |-- ...
+        |       |-- videoFileN.avi
+        |...
+        |   |-- vidDIRM/
+        |       |-- videoFile1.avi
+        |       |-- ...
+        |       |-- videoFileM.avi
+        |...
+        |-- subjDIR_n/
+        |...
+    """
+    name = 'COHFACE'
+    signalGT = 'BVP'         # GT signal type
+    numLevels = 2            # depth of the filesystem collecting video and BVP files
+    numSubjects = 40         # number of subjects
+    video_EXT = 'avi'        # extension of the video files
+    frameRate = 20           # vieo frame rate
+    VIDEO_SUBSTRING = 'data' # substring contained in the filename
+    SIG_EXT = 'hdf5'         # extension of the BVP files
+    SIG_SUBSTRING = 'data'   # substring contained in the filename
+    SIG_SampleRate = 256     # sample rate of the BVP files
+    skinThresh = [40,60]     # thresholds for skin detection
+
+    def readSigfile(self, filename):
+        """ Load BVP signal.
+            Must return a 1-dim (row array) signal
+        """
+
+        f = h5py.File(filename, 'r')
+        data = np.array(f['pulse'])        # load the signal
+        data = data.reshape(1,len(data))   # monodimentional signal
+
+        return BVPsignal(data, self.SIG_SampleRate)

dataset.py

@@ -0,0 +1,66 @@
+from abc import ABCMeta, abstractmethod
+import os
+from importlib import import_module
+
+#def datasetFactory(datasetName, *args, **kwargs):
+def datasetFactory(datasetName, videodataDIR, BVPdataDIR):
+    try:
+        moduleName = datasetName.lower()
+        className = datasetName.upper()
+        datasetModule = import_module('pyVHR.datasets.' + moduleName) #, package='pyVHR')
+        classOBJ = getattr(datasetModule, className)
+        #obj = classOBJ(*args, **kwargs)
+        obj = classOBJ(videodataDIR, BVPdataDIR)
+
+    except (AttributeError, ModuleNotFoundError):
+        raise ImportError('{} is not part of pyVHR dataset collection!'.format(datasetName))
+
+    return obj
+
+class Dataset(metaclass=ABCMeta):
+    """
+    Manage datasets (parent class for new datasets)
+    """
+    def __init__(self, videodataDIR=None, BVPdataDIR=None):
+        # -- load filenames
+        self.videoFilenames = []  # list of all video filenames
+        self.sigFilenames = []    # list of all Sig filenames
+        self.numVideos = 0        # num of videos in the dataset
+        self.videodataDIR = videodataDIR
+        self.BVPdataDIR = BVPdataDIR
+        self.loadFilenames()
+
+    def loadFilenames(self):
+        """Load dataset file names: define vars videoFilenames and BVPFilenames"""
+
+        # -- loop on the dir struct of the dataset getting filenames
+        for root, dirs, files in os.walk(self.videodataDIR):
+            for f in files:
+                filename = os.path.join(root, f)
+                path, name = os.path.split(filename)
+
+                # -- select video
+                if filename.endswith(self.video_EXT) and (name.find(self.VIDEO_SUBSTRING)>=0):
+                    self.videoFilenames.append(filename)
+                   
+                # -- select signal
+                if filename.endswith(self.SIG_EXT) and (name.find(self.SIG_SUBSTRING)>=0):
+                    self.sigFilenames.append(filename)
+
+        # -- number of videos
+        self.numVideos = len(self.videoFilenames)
+
+    def getVideoFilename(self, videoIdx=0):
+        """Get video filename given the progressive index"""
+        return self.videoFilenames[videoIdx]
+
+    def getSigFilename(self, videoIdx=0):
+        """Get Signal filename given the progressive index"""
+        return self.sigFilenames[videoIdx]
+
+    @abstractmethod
+    def readSigfile(self, filename):
+        """ Load signal from file.
+            Return a BVPsignal/ECGsignal object.
+        """
+        pass

default_test.cfg

@@ -0,0 +1,103 @@
+# default_test.cfg - default test configuration file for TestSuite class
+
+## Default parameters
+#
+#  winsize   = Duration of the time window to process the video (in seconds)
+#  winsizeGT = Duration of the time window to process the ground truth signal (in seconds)
+#  timeStep  = Time step of the estimation (in seconds)
+#  methods   = A list of methods to test (['CHROM','Green','ICA','LGI','PBV','PCA','POS','SSR'])
+#
+## Video signal Preprocessing
+#
+#  zeroMeanSTDnorm = Apply Zero Mean and Unit Standard Deviation (0/1)
+#  detrending      = Apply detrenting algorithm (0/1)
+#  detrMethod      = Detrenting algorithm (tarvainen/scipy)
+#  detLambda       = If detrending = 1, regularization parameter of detrending algorithm
+#  BPfilter        = Apply band pass filtering (0/1)
+#  minHz           = If BPfilter = 1, the lower cut-off frequency (in hertz)
+#  maxHz           = If BPfilter = 1, the upper cut-off frequency (in hertz)
+
+[DEFAULT]
+winSize         = 5
+winSizeGT       = 5
+timeStep        = 1
+methods         = ['POS','CHROM']
+zeroMeanSTDnorm = 0
+detrending      = 0
+detLambda       = 10
+BPfilter        = 1
+minHz           = 0.75
+maxHz           = 4.0
+
+## Video signal
+#
+#  dataset      = Name of the dataset to test ('PURE', 'UBFC1', 'UBFC2', 'LGI-PPGI', 'COHFACE', 'MAHNOB')
+#  videoIdx     = A list of IDs reffered to the videos to test (eg. [0,1,2,...]) 
+#                 or the string 'all' to test on the whole database
+#  detector     = Method used for face detection (mtcnn, dlib, mtcnn_kalman)
+#  extractor    = Preferred library to read video files (opencv/skvideo)
+#  startTime    = Process video file from  start time (in seconds)
+#  endTime      = Process video file until end time (in seconds). If < 0: process until (video length - endTime) 
+
+[VIDEO]
+dataset     = lgi_ppgi
+videodataDIR= ../sampleDataset/
+BVPdataDIR  = ../sampleDataset/
+videoIdx    = [0]
+detector    = mtcnn
+extractor   = skvideo
+startTime   = 3
+endTime     = -3
+ROImask = skin_fix
+skinFix   = [40, 60]
+skinAdapt = 0.2
+rectCoords= [[0, 0, 150, 150]]
+evm = 0
+stat = mean
+
+## Method specific configurations
+
+[ICA]
+zeroMeanSTDnorm = 1
+detrending      = 0
+BPfilter        = 1
+ICAmethod       = jade
+
+[PCA]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 1
+minHz           = 0.75
+maxHz           = 4.0
+
+[SSR]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 0
+
+[CHROM]
+zeroMeanSTDnorm = 0
+detrending      = 1
+detrMethod      = scipy
+BPfilter        = 0
+
+[POS]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 0
+
+[LGI]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 0
+
+[PBV]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 0
+
+[GREEN]
+zeroMeanSTDnorm = 0
+detrending      = 1
+detrMethod      = scipy
+BPfilter        = 0

detrending.py

@@ -0,0 +1,13 @@
+import numpy as np
+import scipy.sparse
+
+def detrend(X, detLambda=10):
+    # Smoothness prior approach as in the paper appendix:
+    # "An advanced detrending method with application to HRV analysis"
+    # by Tarvainen, Ranta-aho and Karjaalainen
+    t = X.shape[0]
+    l = t/detLambda #lambda
+    I = np.identity(t)
+    D2 = scipy.sparse.diags([1, -2, 1], [0,1,2],shape=(t-2,t)).toarray() # this works better than spdiags in python
+    detrendedX = (I-np.linalg.inv(I+l**2*(np.transpose(D2).dot(D2)))).dot(X)
+    return detrendedX

ecg.py

@@ -0,0 +1,64 @@
+import numpy as np
+from scipy.signal import find_peaks, stft, lfilter, butter, welch
+from plotly.subplots import make_subplots
+from plotly.colors import n_colors
+import plotly.graph_objects as go
+from biosppy.signals import ecg
+
+
+class ECGsignal:
+    """
+        Manage (multi-channel, row-wise) BVP signals
+    """
+    verb = False   # verbose (True)
+    nFFT = 4*4096  # freq. resolution for STFTs
+    step = 1       # step in seconds
+    minHz = .75    # 39 BPM - min freq.
+    maxHz = 4.    # 240 BPM - max freq.
+
+    def __init__(self, data, fs, startTime=0):
+        #self.data = data
+        if len(data.shape) == 1:
+            self.data = data.reshape(1,-1) # 2D array raw-wise
+        self.fs = fs                       # sample rate
+        self.startTime = startTime
+
+    def getBPM(self, winsize=5):
+        """
+        Compute the ECG signal by biosppy library
+        """
+        # TODO: to handle all channels
+        data = self.data[0,:]
+        out = ecg.ecg(signal=data, sampling_rate=self.fs, show=False)
+        self.times = out['heart_rate_ts'] 
+        self.bpm = out['heart_rate']
+        self.peaksIdX = out['rpeaks']
+        
+        return self.bpm, self.times
+
+    def autocorr(self):
+        from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
+
+        # TODO: to handle all channels
+        x = self.data[0,:]
+        plot_acf(x)
+        plt.show()
+
+        plot_pacf(x)
+        plt.show()
+
+    def plot(self):
+        """
+            Plot the the ECG signals (one channels)
+        """
+        # TODO: to handle all channels
+        data = self.data[0,:]
+        N = len(data)
+        times = np.linspace(self.startTime, N/self.fs, num=N, endpoint=False)
+
+        # -- plot the channel
+        fig = make_subplots(rows=1, cols=1)
+        fig.add_trace(go.Scatter(x=times, y=data, name='ECG'), row=1, col=1)
+        fig.add_trace(go.Scatter(x=self.peaksIdX/self.fs, y=data[self.peaksIdX], mode='markers', name='peaks'), row=1, col=1)
+        fig.update_layout(height=600, width=800)
+        fig.show()

elapse.py

@@ -0,0 +1,19 @@
+import time
+
+def tic(verb=True):
+    """ tic like Matlab function """
+
+    global tic_toc_time
+    tic_toc_time = time.time()
+    if verb:
+        print('start...')
+    return tic_toc_time
+
+def toc(verb=True):
+    """ toc like Matlab function """
+
+    global tic_toc_time
+    T1 = time.time()-tic_toc_time
+    if verb:
+        print('elapsed = ' + str(T1))
+    return T1

errors.py

@@ -0,0 +1,119 @@
+import numpy as np
+import plotly.graph_objects as go
+from pyVHR.signals.bvp import BVPsignal
+
+def getErrors(bpmES, bpmGT, timesES, timesGT):
+    RMSE = RMSEerror(bpmES, bpmGT, timesES, timesGT)
+    MAE = MAEerror(bpmES, bpmGT, timesES, timesGT)
+    MAX = MAXError(bpmES, bpmGT, timesES, timesGT)
+    PCC = PearsonCorr(bpmES, bpmGT, timesES, timesGT)
+    return RMSE, MAE, MAX, PCC
+
+def RMSEerror(bpmES, bpmGT, timesES=None, timesGT=None):
+    """ RMSE: """
+
+    diff = bpm_diff(bpmES, bpmGT, timesES, timesGT)
+    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(bpmES, bpmGT, timesES=None, timesGT=None):
+    """ MAE: """
+
+    diff = bpm_diff(bpmES, bpmGT, timesES, timesGT)
+    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(bpmES, bpmGT, timesES=None, timesGT=None):
+    """ MAE: """
+
+    diff = bpm_diff(bpmES, bpmGT, timesES, timesGT)
+    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(bpmES, bpmGT, timesES=None, timesGT=None):
+    from scipy import stats
+
+    diff = bpm_diff(bpmES, bpmGT, timesES, timesGT)
+    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(RMSE, MAE, MAX, PCC):
+    print("\n    * Errors: RMSE = %.2f, MAE = %.2f, MAX = %.2f, PCC = %.2f" %(RMSE,MAE,MAX,PCC))
+
+def displayErrors(bpmES, bpmGT, timesES=None, timesGT=None):
+    
+    if (timesES is None) or (timesGT is None):
+        timesES = np.arange(m)
+        timesGT = timesES
+        
+    diff = bpm_diff(bpmES, bpmGT, timesES, timesGT)
+    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 bpm_diff(bpmES, bpmGT, timesES=None, timesGT=None):
+    n,m = bpmES.shape  # n = num channels, m = bpm length
+
+    if (timesES is None) or (timesGT is None):
+        timesES = np.arange(m)
+        timesGT = timesES
+            
+    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

evm.py

@@ -0,0 +1,142 @@
+import argparse
+import numpy as np
+import cv2
+import scipy.signal as signal
+import scipy.fftpack as fftpack
+
+
+def build_gaussian_pyramid(src, levels=3):
+    """
+    Function: build_gaussian_pyramid
+    --------------------------------
+        Builds a gaussian pyramid
+
+    Args:
+    -----
+        src: the input image
+        levels: the number levels in the gaussian pyramid
+
+    Returns:
+    --------
+        A gaussian pyramid
+    """
+    s = src.copy()
+    pyramid = [s]
+    print(s.shape)
+    for i in range(levels):
+        s = cv2.pyrDown(s)
+        pyramid.append(s)
+        
+        print(s.shape)
+        
+    return pyramid
+
+
+def gaussian_video(video, levels=3):
+    """
+    Function: gaussian_video
+    ------------------------
+       generates a gaussian pyramid for each frame in a video
+
+    Args:
+    -----
+        video: the input video array
+        levels: the number of levels in the gaussian pyramid
+
+    Returns:
+    --------
+        the gaussian video
+    """
+    n = video.shape[0]
+    for i in range(0, n):
+        pyr = build_gaussian_pyramid(video[i], levels=levels)
+        gaussian_frame=pyr[-1]
+        if i==0:
+            vid_data = np.zeros((n, *gaussian_frame.shape))
+        vid_data[i] = gaussian_frame
+    return vid_data
+
+def temporal_ideal_filter(arr, low, high, fps, axis=0):
+    """
+    Function: temporal_ideal_filter
+    -------------------------------
+       Applies a temporal ideal filter to a numpy array
+    Args:
+    -----
+        arr: a numpy array with shape (N, H, W, C)
+            N: number of frames
+            H: height
+            W: width
+            C: channels
+        low: the low frequency bound
+        high: the high frequency bound
+        fps: the video frame rate
+        axis: the axis of video, should always be 0
+    Returns:
+    --------
+        the array with the filter applied
+    """
+    fft = fftpack.fft(arr, axis=axis)
+    frequencies = fftpack.fftfreq(arr.shape[0], d=1.0 / fps)
+    bound_low = (np.abs(frequencies - low)).argmin()
+    bound_high = (np.abs(frequencies - high)).argmin()
+    fft[:bound_low] = 0
+    fft[bound_high:-bound_high] = 0
+    fft[-bound_low:] = 0
+    iff=fftpack.ifft(fft, axis=axis)
+    return np.abs(iff)
+
+
+def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
+    """
+    Function: butter_bandpass_filter
+    --------------------------------
+        applies a buttersworth bandpass filter
+    Args:
+    -----
+        data: the input data
+        lowcut: the low cut value
+        highcut: the high cut value
+        fs: the frame rate in frames per second
+        order: the order for butter
+    Returns:
+    --------
+        the result of the buttersworth bandpass filter
+    """
+    omega = 0.5 * fs
+    low = lowcut / omega
+    high = highcut / omega
+    b, a = signal.butter(order, [low, high], btype='band')
+    y = signal.lfilter(b, a, data, axis=0)
+    return y
+
+def reconstruct_video_g(amp_video, original_video, levels=3):
+    """
+    Function: reconstruct_video_g
+    -----------------------------
+        reconstructs a video from a gaussian pyramid and the original
+
+    Args:
+    -----
+        amp_video: the amplified gaussian video
+        original_video: the original video
+        levels: the levels in the gaussian video
+
+    Returns:
+    --------
+        the reconstructed video
+    """
+    
+    print(original_video.shape)
+    final_video = np.zeros(original_video.shape)
+    for i in range(0, amp_video.shape[0]):
+        img = amp_video[i]
+        print(img.shape)
+        for x in range(levels):
+            img = cv2.pyrUp(img)
+        
+            print(img.shape)
+        
+        img = img + original_video[i]
+        final_video[i] = img
+    return final_video

evm2.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+
+"""
+Eulerian Video Magnification (EVM) Demo
+"""
+
+import time
+import sys
+
+import cv2
+import numpy as np
+import scipy
+import skimage
+
+def gaussian(image, numlevels):
+	"""Constructs gaussian pyramid
+
+	Arguments:
+		image : Input image (monochrome or color)
+		numlevels : Number of levels to compute
+
+	Return:
+		List of progressively smaller (i.e. lower frequency) images
+	"""
+
+	pyramid = [ image ]
+	for level in range(numlevels):
+		image = cv2.pyrDown(image)
+		pyramid.append(image)
+
+	return pyramid
+
+def temporal_bandpass_filter(data, freq_min, freq_max, fps, axis=0):
+	"""Applies ideal band-pass filter to a given video
+	Arguments:
+		data : video to be filtered (as a 4-d numpy array (time, height,
+		        width, channels))
+		freq_min : lower cut-off frequency of band-pass filter
+		freq_max : upper cut-off frequency of band-pass filter
+		fps :
+	Return:
+		Temporally filtered video as 4-d array
+	"""
+
+	# perform FFT on each frame
+	fft = scipy.fftpack.fft(data, axis=axis)
+	# sampling frequencies, where the step d is 1/samplingRate
+	frequencies = scipy.fftpack.fftfreq(data.shape[0], d=1.0 / fps)
+	# find the indices of low cut-off frequency
+	bound_low = (np.abs(frequencies - freq_min)).argmin()
+	# find the indices of high cut-off frequency
+	bound_high = (np.abs(frequencies - freq_max)).argmin()
+	# band pass filtering
+	fft[:bound_low] = 0
+	fft[-bound_low:] = 0
+	fft[bound_high:-bound_high] = 0
+	# perform inverse FFT
+	return np.real(scipy.fftpack.ifft(fft, axis=0))
+
+class EVM():
+	"""Eulerian Video Magnification"""
+
+	def __init__(self, frames, fps):
+		"""Constructor"""
+		self.fps = fps
+		self.frames = frames
+		self.frameCount = len(frames)
+		self.frameHeight = int(frames[0].shape[0])
+		self.frameWidth = int(frames[0].shape[1])
+		self.numChannels = 3
+		# allocate memory for input frames
+		self.in_frames = frames
+		self.out_frames = frames
+
+	def process(self, numlevels=4, alpha=50., chromAttenuation=1., lowcut=0.5, highcut=1.5):
+		"""Process video
+
+		Arguments:
+			numlevels : Number of pyramid levels to compute
+		"""
+		# compute pyramid on first frame
+		pyramid = gaussian(self.in_frames[0], numlevels)
+		height, width, _ = pyramid[-1].shape
+
+		# allocate memory for downsampled frames
+		self.ds_frames = np.ndarray(shape=(self.frameCount, \
+		                                   height, \
+		                                   width, \
+		                                   self.numChannels), \
+		                            dtype=np.float32)
+		self.ds_frames[0] = pyramid[-1]
+
+		for frameNumber in range(1, self.frameCount):
+
+			# spatial decomposition (specify laplacian or gaussian)
+			pyramid = gaussian(self.in_frames[frameNumber], numlevels)
+
+			# store downsampled frame into memory
+			self.ds_frames[frameNumber] = pyramid[-1]
+
+		#print ('filtering...')
+		output = temporal_bandpass_filter(self.ds_frames, lowcut, highcut, self.fps)
+
+		#print ('amplifying...')
+		output[:,:,:,0] *= alpha
+		output[:,:,:,1] *= (alpha * chromAttenuation)
+		output[:,:,:,2] *= (alpha * chromAttenuation)
+
+		for i in range(self.frameCount):
+
+			orig = self.in_frames[i]
+
+			filt = output[i].astype(np.float32)
+
+			# enlarge to match size of original frame (keep as 32-bit float)
+			filt = cv2.resize(filt, (self.frameWidth, self.frameHeight), interpolation=cv2.INTER_CUBIC)
+
+			filt = filt + orig
+
+			filt = skimage.color.yiq2rgb(filt)
+
+			#filt[filt > 1] = 1
+			#filt[filt < 0] = 0
+
+			self.out_frames[i] = filt
+
+		return self.out_frames
+
+def main(frames, fps, alpha, numlevels):
+	evm = EVM(frames, fps)
+	filt = evm.process(alpha=alpha, numlevels=numlevels)
+
+	return filt

filters.py

@@ -0,0 +1,36 @@
+import numpy as np
+from scipy.signal import butter, lfilter, filtfilt, freqz
+from scipy import signal
+
+def BPfilter(x, minHz, maxHz, fs, order=6):
+    """Band Pass filter (using BPM band)"""
+
+    #nyq = fs * 0.5
+    #low = minHz/nyq
+    #high = maxHz/nyq
+
+    #print(low, high)
+    #-- filter type
+    #print('filtro=%f' % minHz)
+    b, a = butter(order, Wn=[minHz, maxHz], fs=fs, btype='bandpass')
+    #TODO verificare filtfilt o lfilter
+    #y = lfilter(b, a, x)
+    y = filtfilt(b, a, x)
+
+    #w, h = freqz(b, a)
+
+
+    #import matplotlib.pyplot as plt
+    #fig, ax1 = plt.subplots()
+    #ax1.set_title('Digital filter frequency response')
+    #ax1.plot((fs * 0.5 / np.pi) * w, abs(h), 'b')
+    #ax1.set_ylabel('Amplitude [dB]', color='b')
+    #plt.show()
+    return y
+
+def zeroMeanSTDnorm(x):
+    # -- normalization along rows (1-3 channels)
+    mx = x.mean(axis=1).reshape(-1,1)
+    sx = x.std(axis=1).reshape(-1,1)
+    y = (x - mx) / sx
+    return y

green.py

@@ -0,0 +1,15 @@
+from scipy import signal
+import numpy as np
+from .base import VHRMethod
+
+class GREEN(VHRMethod):
+    methodName = 'GREEN'
+    
+    def __init__(self, **kwargs):
+        super(GREEN, self).__init__(**kwargs)
+        
+    def apply(self, X):
+
+        bvp = X[1,:].T
+
+        return bvp

ica.py

@@ -0,0 +1,43 @@
+import numpy as np
+from scipy import signal
+from .utils.jade import jadeR
+from .base import VHRMethod
+
+class ICA(VHRMethod):
+    methodName = 'ICA'
+    
+    def __init__(self, **kwargs):
+        self.tech = kwargs['ICAmethod']  
+        super(ICA, self).__init__(**kwargs)
+
+    def apply(self, X):
+        """ ICA method """
+        
+        # -- JADE (ICA)
+        if self.tech == 'jade':
+            W = self.__jade(X)
+        elif 'fastICA':
+            W = self.__fastICA(X)
+            
+        bvp = np.dot(W,X) # 3-dim signal!!
+        
+        return bvp
+
+
+    def __jade(self, X):
+        W = np.asarray(jadeR(X, 3, False))
+        return W
+
+    def __fastICA(self, X):
+        from sklearn.decomposition import FastICA, PCA
+        from numpy.linalg import inv, eig
+
+        # -- PCA
+        pca = PCA(n_components=3)
+        Y = pca.fit_transform(X)
+
+        # -- ICA
+        ica = FastICA(n_components=3, max_iter=2000)
+        S = ica.fit_transform(Y)
+
+        return S.T        

jade.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Mar 22 11:12:29 2017
+
+@author: juliette
+"""
+
+#######################################################################
+# jade.py -- Blind source separation of real signals
+#
+# Version 1.8
+#
+# Copyright 2005, Jean-Francois Cardoso (Original MATLAB code)
+# Copyright 2007, Gabriel J.L. Beckers (NumPy translation)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#######################################################################
+
+"""
+jade
+
+This module contains only one function, jadeR, which does blind source
+separation of real signals. Hopefully more ICA algorithms will be added in the
+future.
+"""
+
+from sys import stdout
+from numpy import abs, append, arange, arctan2, argsort, array, concatenate, \
+    cos, diag, dot, eye, float32, float64, matrix, multiply, ndarray, newaxis, \
+    sign, sin, sqrt, zeros
+from numpy.linalg import eig, pinv
+
+
+def jadeR(X, m=None, verbose=True):
+    """
+    Blind separation of real signals with JADE.
+
+    jadeR implements JADE, an Independent Component Analysis (ICA) algorithm
+    developed by Jean-Francois Cardoso. See
+    http://www.tsi.enst.fr/~cardoso/guidesepsou.html , and papers cited
+    at the end of the source file.
+
+    Translated into NumPy from the original Matlab Version 1.8 (May 2005) by
+    Gabriel Beckers, http://gbeckers.nl .
+
+    Parameters:
+
+        X -- an nxT data matrix (n sensors, T samples). May be a numpy array or
+             matrix.
+
+        m -- output matrix B has size mxn so that only m sources are
+             extracted.  This is done by restricting the operation of jadeR
+             to the m first principal components. Defaults to None, in which
+             case m=n.
+
+        verbose -- print info on progress. Default is True.
+
+    Returns:
+
+        An m*n matrix B (NumPy matrix type), such that Y=B*X are separated
+        sources extracted from the n*T data matrix X. If m is omitted, B is a
+        square n*n matrix (as many sources as sensors). The rows of B are
+        ordered such that the columns of pinv(B) are in order of decreasing
+        norm; this has the effect that the `most energetically significant`
+        components appear first in the rows of Y=B*X.
+
+    Quick notes (more at the end of this file):
+
+    o This code is for REAL-valued signals.  A MATLAB implementation of JADE
+        for both real and complex signals is also available from
+        http://sig.enst.fr/~cardoso/stuff.html
+
+    o This algorithm differs from the first released implementations of
+        JADE in that it has been optimized to deal more efficiently
+        1) with real signals (as opposed to complex)
+        2) with the case when the ICA model does not necessarily hold.
+
+    o There is a practical limit to the number of independent
+        components that can be extracted with this implementation.  Note
+        that the first step of JADE amounts to a PCA with dimensionality
+        reduction from n to m (which defaults to n).  In practice m
+        cannot be `very large` (more than 40, 50, 60... depending on
+        available memory)
+
+    o See more notes, references and revision history at the end of
+        this file and more stuff on the WEB
+        http://sig.enst.fr/~cardoso/stuff.html
+
+    o For more info on NumPy translation, see the end of this file.
+
+    o This code is supposed to do a good job!  Please report any
+        problem relating to the NumPY code gabriel@gbeckers.nl
+
+    Copyright original Matlab code : Jean-Francois Cardoso <cardoso@sig.enst.fr>
+    Copyright Numpy translation : Gabriel Beckers <gabriel@gbeckers.nl>
+    """
+
+    # GB: we do some checking of the input arguments and copy data to new
+    # variables to avoid messing with the original input. We also require double
+    # precision (float64) and a numpy matrix type for X.
+
+    assert isinstance(X, ndarray),\
+        "X (input data matrix) is of the wrong type (%s)" % type(X)
+    origtype = X.dtype # remember to return matrix B of the same type
+    X = matrix(X.astype(float64))
+    assert X.ndim == 2, "X has %d dimensions, should be 2" % X.ndim
+    assert (verbose == True) or (verbose == False), \
+        "verbose parameter should be either True or False"
+
+    [n,T] = X.shape # GB: n is number of input signals, T is number of samples
+
+    if m==None:
+        m=n 	# Number of sources defaults to # of sensors
+    assert m<=n,\
+        "jade -> Do not ask more sources (%d) than sensors (%d )here!!!" % (m,n)
+
+    if verbose:
+        print ("jade -> Looking for %d sources" % m)
+        print ( "jade -> Removing the mean value")
+    X -= X.mean(1)
+
+    # whitening & projection onto signal subspace
+    # ===========================================
+    if verbose:
+        print ("jade -> Whitening the data")
+    [D,U] = eig((X * X.T) / float(T)) # An eigen basis for the sample covariance matrix
+    k = D.argsort()
+    Ds = D[k] # Sort by increasing variances
+    PCs = arange(n-1, n-m-1, -1)    # The m most significant princip. comp. by decreasing variance
+
+    # --- PCA  ----------------------------------------------------------
+    B = U[:,k[PCs]].T    # % At this stage, B does the PCA on m components
+
+    # --- Scaling  ------------------------------------------------------
+    scales = sqrt(Ds[PCs]) # The scales of the principal components .
+    B = diag(1./scales) * B  # Now, B does PCA followed by a rescaling = sphering
+    #B[-1,:] = -B[-1,:] # GB: to make it compatible with octave
+    # --- Sphering ------------------------------------------------------
+    X = B * X # %% We have done the easy part: B is a whitening matrix and X is white.
+
+    del U, D, Ds, k, PCs, scales
+
+    # NOTE: At this stage, X is a PCA analysis in m components of the real data, except that
+    # all its entries now have unit variance.  Any further rotation of X will preserve the
+    # property that X is a vector of uncorrelated components.  It remains to find the
+    # rotation matrix such that the entries of X are not only uncorrelated but also `as
+    # independent as possible".  This independence is measured by correlations of order
+    # higher than 2.  We have defined such a measure of independence which
+    #   1) is a reasonable approximation of the mutual information
+    #   2) can be optimized by a `fast algorithm"
+    # This measure of independence also corresponds to the `diagonality" of a set of
+    # cumulant matrices.  The code below finds the `missing rotation " as the matrix which
+    # best diagonalizes a particular set of cumulant matrices.
+
+
+    # Estimation of the cumulant matrices.
+    # ====================================
+    if verbose:
+        print ("jade -> Estimating cumulant matrices")
+
+    # Reshaping of the data, hoping to speed up things a little bit...
+    X = X.T
+    dimsymm = int((m * ( m + 1)) / 2)	# Dim. of the space of real symm matrices
+    nbcm = dimsymm  # number of cumulant matrices
+    CM = matrix(zeros([m,m*nbcm], dtype=float64)) # Storage for cumulant matrices
+    R = matrix(eye(m, dtype=float64))
+    Qij = matrix(zeros([m,m], dtype=float64)) # Temp for a cum. matrix
+    Xim	= zeros(m, dtype=float64) # Temp
+    Xijm = zeros(m, dtype=float64) # Temp
+    #Uns = numpy.ones([1,m], dtype=numpy.uint32)    # for convenience
+    # GB: we don't translate that one because NumPy doesn't need Tony's rule
+
+    # I am using a symmetry trick to save storage.  I should write a short note one of these
+    # days explaining what is going on here.
+    Range = arange(m) # will index the columns of CM where to store the cum. mats.
+
+    for im in range(m):
+        Xim = X[:,im]
+        Xijm = multiply(Xim, Xim)
+        # Note to myself: the -R on next line can be removed: it does not affect
+        # the joint diagonalization criterion
+        Qij = multiply(Xijm, X).T * X / float(T)\
+            - R - 2 * dot(R[:,im], R[:,im].T)
+        CM[:,Range] = Qij
+        Range = Range  + m
+        for jm in range(im):
+            Xijm = multiply(Xim, X[:,jm])
+            Qij = sqrt(2) * multiply(Xijm, X).T * X / float(T) \
+                - R[:,im] * R[:,jm].T - R[:,jm] * R[:,im].T
+            CM[:,Range]	= Qij
+            Range = Range + m
+
+    # Now we have nbcm = m(m+1)/2 cumulants matrices stored in a big m x m*nbcm array.
+
+    V = matrix(eye(m, dtype=float64))
+
+    Diag = zeros(m, dtype=float64)
+    On = 0.0
+    Range = arange(m)
+    for im in range(nbcm):
+        Diag = diag(CM[:,Range])
+        On = On + (Diag*Diag).sum(axis=0)
+        Range = Range + m
+    Off = (multiply(CM,CM).sum(axis=0)).sum(axis=0) - On
+
+    seuil = 1.0e-6 / sqrt(T) # % A statistically scaled threshold on `small" angles
+    encore = True
+    sweep = 0 # % sweep number
+    updates = 0 # % Total number of rotations
+    upds = 0 # % Number of rotations in a given seep
+    g = zeros([2,nbcm], dtype=float64)
+    gg = zeros([2,2], dtype=float64)
+    G = zeros([2,2], dtype=float64)
+    c = 0
+    s = 0
+    ton	= 0
+    toff = 0
+    theta = 0
+    Gain = 0
+
+    # Joint diagonalization proper
+
+    if verbose:
+        print ( "jade -> Contrast optimization by joint diagonalization")
+
+    while encore:
+        encore = False
+        if verbose:
+            print("jade -> Sweep #%3d" % sweep)
+        sweep = sweep + 1
+        upds  = 0
+        Vkeep = V
+
+        for p in range(m-1):
+            for q in range(p+1, m):
+
+                Ip = arange(p, m*nbcm, m)
+                Iq = arange(q, m*nbcm, m)
+
+                # computation of Givens angle
+                g = concatenate([CM[p,Ip] - CM[q,Iq], CM[p,Iq] + CM[q,Ip]])
+                gg = dot(g, g.T)
+                ton = gg[0,0] - gg[1,1]
+                toff = gg[0,1] + gg[1,0]
+                theta = 0.5 * arctan2(toff, ton + sqrt(ton * ton + toff * toff))
+                Gain = (sqrt(ton * ton + toff * toff) - ton) / 4.0
+
+                # Givens update
+                if abs(theta) > seuil:
+                    encore = True
+                    upds = upds + 1
+                    c = cos(theta)
+                    s = sin(theta)
+                    G = matrix([[c, -s] , [s, c] ])
+                    pair = array([p,q])
+                    V[:,pair] = V[:,pair] * G
+                    CM[pair,:] = G.T * CM[pair,:]
+                    CM[:,concatenate([Ip,Iq])] = \
+                        append( c*CM[:,Ip]+s*CM[:,Iq], -s*CM[:,Ip]+c*CM[:,Iq], \
+                               axis=1)
+                    On = On + Gain
+                    Off = Off - Gain
+
+        if verbose:
+            print ( "completed in %d rotations" % upds)
+        updates = updates + upds
+    if verbose:
+        print ("jade -> Total of %d Givens rotations" % updates)
+
+    # A separating matrix
+    # ===================
+
+    B = V.T * B
+
+    # Permute the rows of the separating matrix B to get the most energetic components first.
+    # Here the **signals** are normalized to unit variance.  Therefore, the sort is
+    # according to the norm of the columns of A = pinv(B)
+
+    if verbose:
+        print("jade -> Sorting the components")
+
+    A = pinv(B)
+    keys =  array(argsort(multiply(A,A).sum(axis=0)[0]))[0]
+    B = B[keys,:]
+    B = B[::-1,:]     # % Is this smart ?
+
+
+    if verbose:
+        print ("jade -> Fixing the signs")
+    b	= B[:,0]
+    signs = array(sign(sign(b)+0.1).T)[0] # just a trick to deal with sign=0
+    B = diag(signs) * B
+
+    return B.astype(origtype)
+
+
+    # Revision history of MATLAB code:
+    #
+    #- V1.8, May 2005
+    #  - Added some commented code to explain the cumulant computation tricks.
+    #  - Added reference to the Neural Comp. paper.
+    #
+    #-  V1.7, Nov. 16, 2002
+    #   - Reverted the mean removal code to an earlier version (not using
+    #     repmat) to keep the code octave-compatible.  Now less efficient,
+    #     but does not make any significant difference wrt the total
+    #     computing cost.
+    #   - Remove some cruft (some debugging figures were created.  What
+    #     was this stuff doing there???)
+    #
+    #
+    #-  V1.6, Feb. 24, 1997
+    #   - Mean removal is better implemented.
+    #   - Transposing X before computing the cumulants: small speed-up
+    #   - Still more comments to emphasize the relationship to PCA
+    #
+    #-  V1.5, Dec. 24 1997
+    #   - The sign of each row of B is determined by letting the first element be positive.
+    #
+    #-  V1.4, Dec. 23 1997
+    #   - Minor clean up.
+    #   - Added a verbose switch
+    #   - Added the sorting of the rows of B in order to fix in some reasonable way the
+    #     permutation indetermination.  See note 2) below.
+    #
+    #-  V1.3, Nov.  2 1997
+    #   - Some clean up.  Released in the public domain.
+    #
+    #-  V1.2, Oct.  5 1997
+    #   - Changed random picking of the cumulant matrix used for initialization to a
+    #     deterministic choice.  This is not because of a better rationale but to make the
+    #     ouput (almost surely) deterministic.
+    #   - Rewrote the joint diag. to take more advantage of Matlab"s tricks.
+    #   - Created more dummy variables to combat Matlab"s loose memory management.
+    #
+    #-  V1.1, Oct. 29 1997.
+    #    Made the estimation of the cumulant matrices more regular. This also corrects a
+    #    buglet...
+    #
+    #-  V1.0, Sept. 9 1997. Created.
+    #
+    # Main references:
+    # @article{CS-iee-94,
+    #  title 	= "Blind beamforming for non {G}aussian signals",
+    #  author       = "Jean-Fran\c{c}ois Cardoso and Antoine Souloumiac",
+    #  HTML 	= "ftp://sig.enst.fr/pub/jfc/Papers/iee.ps.gz",
+    #  journal      = "IEE Proceedings-F",
+    #  month = dec, number = 6, pages = {362-370}, volume = 140, year = 1993}
+    #
+    #
+    #@article{JADE:NC,
+    #  author  = "Jean-Fran\c{c}ois Cardoso",
+    #  journal = "Neural Computation",
+    #  title   = "High-order contrasts for independent component analysis",
+    #  HTML    = "http://www.tsi.enst.fr/~cardoso/Papers.PS/neuralcomp_2ppf.ps",
+    #  year    = 1999, month =	jan,  volume =	 11,  number =	 1,  pages =	 "157-192"}
+    #
+    #
+    #  Notes:
+    #  ======
+    #
+    #  Note 1) The original Jade algorithm/code deals with complex signals in Gaussian noise
+    #  white and exploits an underlying assumption that the model of independent components
+    #  actually holds.  This is a reasonable assumption when dealing with some narrowband
+    #  signals.  In this context, one may i) seriously consider dealing precisely with the
+    #  noise in the whitening process and ii) expect to use the small number of significant
+    #  eigenmatrices to efficiently summarize all the 4th-order information.  All this is done
+    #  in the JADE algorithm.
+    #
+    #  In *this* implementation, we deal with real-valued signals and we do NOT expect the ICA
+    #  model to hold exactly.  Therefore, it is pointless to try to deal precisely with the
+    #  additive noise and it is very unlikely that the cumulant tensor can be accurately
+    #  summarized by its first n eigen-matrices.  Therefore, we consider the joint
+    #  diagonalization of the *whole* set of eigen-matrices.  However, in such a case, it is
+    #  not necessary to compute the eigenmatrices at all because one may equivalently use
+    #  `parallel slices" of the cumulant tensor.  This part (computing the eigen-matrices) of
+    #  the computation can be saved: it suffices to jointly diagonalize a set of cumulant
+    #  matrices.  Also, since we are dealing with reals signals, it becomes easier to exploit
+    #  the symmetries of the cumulants to further reduce the number of matrices to be
+    #  diagonalized.  These considerations, together with other cheap tricks lead to this
+    #  version of JADE which is optimized (again) to deal with real mixtures and to work
+    #  `outside the model'.  As the original JADE algorithm, it works by minimizing a `good
+    #  set' of cumulants.
+    #
+    #  Note 2) The rows of the separating matrix B are resorted in such a way that the columns
+    #  of the corresponding mixing matrix A=pinv(B) are in decreasing order of (Euclidian)
+    #  norm.  This is a simple, `almost canonical" way of fixing the indetermination of
+    #  permutation.  It has the effect that the first rows of the recovered signals (ie the
+    #  first rows of B*X) correspond to the most energetic *components*.  Recall however that
+    #  the source signals in S=B*X have unit variance.  Therefore, when we say that the
+    #  observations are unmixed in order of decreasing energy, this energetic signature is to
+    #  be found as the norm of the columns of A=pinv(B) and not as the variances of the
+    #  separated source signals.
+    #
+    #  Note 3) In experiments where JADE is run as B=jadeR(X,m) with m varying in range of
+    #  values, it is nice to be able to test the stability of the decomposition.  In order to
+    #  help in such a test, the rows of B can be sorted as described above. We have also
+    #  decided to fix the sign of each row in some arbitrary but fixed way.  The convention is
+    #  that the first element of each row of B is positive.
+    #
+    #  Note 4) Contrary to many other ICA algorithms, JADE (or least this version) does not
+    #  operate on the data themselves but on a statistic (the full set of 4th order cumulant).
+    #  This is represented by the matrix CM below, whose size grows as m^2 x m^2 where m is
+    #  the number of sources to be extracted (m could be much smaller than n).  As a
+    #  consequence, (this version of) JADE will probably choke on a `large' number of sources.
+    #  Here `large' depends mainly on the available memory and could be something like 40 or
+    #  so.  One of these days, I will prepare a version of JADE taking the `data' option
+    #  rather than the `statistic' option.
+
+    # Notes on translation (GB):
+    # =========================
+    #
+    # Note 1) The function jadeR is a relatively literal translation from the original MATLAB
+    # code. I haven't really looked into optimizing it for NumPy. If you have any time to look
+    # at this and good ideas, let me know.
+    #
+    # Note 2) A test module that compares NumPy output with Octave (MATLAB
+    # clone) output of the original MATLAB script is available

lgi.py

@@ -0,0 +1,25 @@
+import numpy as np
+from scipy import signal
+from .base import VHRMethod
+
+class LGI(VHRMethod):
+    methodName = 'LGI'
+    
+    def __init__(self, **kwargs):
+        super(LGI, self).__init__(**kwargs)
+        
+    def apply(self, X):
+
+        #M = np.mean(X, axis=1)
+        #M = M[:, np.newaxis]
+        #Xzero = X - M   # zero mean (row)
+        
+        U,_,_ = np.linalg.svd(X)
+
+        S = U[:,0].reshape(1,-1) # array 2D shape (1,3)
+        P = np.identity(3) - np.matmul(S.T,S)
+
+        Y = np.dot(P,X)
+        bvp = Y[1,:]
+
+        return bvp

lgi_ppgi.py

@@ -0,0 +1,61 @@
+import xml.etree.ElementTree as ET
+import numpy as np
+from os import path
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class LGI_PPGI(Dataset):
+    """
+    LGI-PPGI dataset structure:
+    -----------------
+        datasetDIR/
+        |
+        |-- vidDIR1/
+        |   |-- videoFile1.avi
+        |
+        |...
+        |
+        |-- vidDIRM/
+            |-- videoFile1.avi
+    """
+    name = 'LGI_PPGI'
+    signalGT = 'BVP'          # GT signal type
+    numLevels = 2             # depth of the filesystem collecting video and BVP files
+    numSubjects = 4           # number of subjects
+    video_EXT = 'avi'         # extension of the video files
+    frameRate = 25            # vieo frame rate
+    VIDEO_SUBSTRING = 'cv_camera'  # substring contained in the filename
+    SIG_EXT = 'xml'           # extension of the BVP files
+    SIG_SUBSTRING = 'cms50'   # substring contained in the filename
+    SIG_SampleRate = 60       # sample rate of the BVP files
+
+    def readSigfile(self, filename):
+        """
+            Load BVP signal. Must return a 1-dim (row array) signal
+        """
+
+        tree = ET.parse(filename)
+        # get all bvp elements and their values
+        bvp_elements = tree.findall('.//*/value2')
+        bvp = [int(item.text) for item in bvp_elements]
+        
+        n_bvp_samples = len(bvp)
+        last_bvp_time = int((n_bvp_samples*1000)/self.SIG_SampleRate)
+
+        vid_xml_filename = path.join(path.dirname(filename), 'cv_camera_sensor_timer_stream_handler.xml')
+        tree = ET.parse(vid_xml_filename)
+        
+        root = tree.getroot()
+        last_vid_time = int(float(root[-1].find('value1').text))
+
+        diff = ((last_bvp_time - last_vid_time)/1000)
+
+        assert diff >= 0, 'Unusable data.'
+
+        print("Skipping %.2f seconds..." % diff)
+
+        diff_samples = round(diff*self.SIG_SampleRate)
+
+        data = np.array(bvp[diff_samples:])
+
+        return BVPsignal(data, self.SIG_SampleRate)

mahnob.py

@@ -0,0 +1,40 @@
+
+import numpy as np
+import pybdf
+from biosppy.signals import ecg
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.ecg import ECGsignal
+
+class MAHNOB(Dataset):
+    """
+    Mahnob dataset structure:
+    -----------------
+        datasetDIR/
+        |
+        ||-- vidDIR1/
+        |   |-- videoFile.avi
+        |   |-- physioFile.bdf
+        |...
+        |...
+    """
+    name = 'MAHNOB'
+    signalGT = 'ECG'     # GT signal type
+    numLevels = 2        # depth of the filesystem collecting video and BVP files
+    numSubjects = 40     # number of subjects
+    video_EXT = 'avi'    # extension of the video files
+    frameRate = 20       # video frame rate
+    VIDEO_SUBSTRING = 'Section'  # substring contained in the filename
+    SIG_EXT = 'bdf'     # extension of the ECG files
+    SIG_SUBSTRING = 'emotion' # substring contained in the filename
+    SIG_SampleRate = 256 # sample rate of the ECG files
+
+    def readSigfile(self, filename):
+        """ Load ECG signal.
+            Return a 2-dim signal (t, bmp(t))
+        """
+        bdfRec = pybdf.bdfRecording(filename)
+        rec = bdfRec.getData(channels=[33])
+        self.SIG_SampleRate = bdfRec.sampRate[33]
+        data = np.array(rec['data'][0])[rec['eventTable']['idx'][2]:]
+        return ECGsignal(data, self.SIG_SampleRate)
+        

multi_dataset_analysis_SPLIT.py

@@ -0,0 +1,283 @@
+import sys
+sys.path.append("..")
+import pandas as pd
+import numpy as np
+import os
+import re 
+import matplotlib.pyplot as plt
+import scipy.stats as ss
+import scikit_posthocs as sp
+import pandas as pd
+
+def sort_nicely(l): 
+    """ Sort the given list in the way that humans expect. 
+    """ 
+    convert = lambda text: int(text) if text.isdigit() else text 
+    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] 
+    l.sort( key=alphanum_key ) 
+
+    return l
+
+
+DATASETS = ['PURE', 'UBFC1', 'UBFC2', 'LGI-PPGI']
+#DATASETS = ['PURE', 'UBFC1', 'UBFC2', 'LGI-PPGI', 'Cohface', 'Mahnob']
+#DATASETS = ['Cohface', 'Mahnob']
+all_methods = ['CHROM','Green','ICA','LGI','PBV','PCA','POS','SSR']
+metrics = ['CC', 'MAE']
+
+avg_type = 'mean'
+#avg_type = 'median'
+
+data_CC = []
+data_MAE = []
+
+for r,DATASET in enumerate(DATASETS):
+    
+    #Experiment Path
+    exp_path = '../results/' + DATASET + '/'
+    files = sort_nicely(os.listdir(exp_path))
+
+    #---------------- Produce Box plots for each method on a given dataset -----------
+
+    win_to_use = 10
+
+    f_to_use = [i for i in files if 'winSize'+str(win_to_use) in i][0]
+    path = exp_path + f_to_use
+    res = pd.read_hdf(path)
+
+    print('\n\n\t\t' + DATASET + '\n\n')
+
+    if DATASET == 'UBFC1' or DATASET == 'UBFC2' or DATASET == 'Mahnob' or DATASET == 'UBFC_ALL':
+
+        all_vals_CC = []
+        all_vals_MAE = []
+        curr_dataCC = np.zeros(len(all_methods))
+        curr_dataMAE = np.zeros(len(all_methods))
+        
+        for metric in metrics:
+            for method in all_methods:
+                #print(method)
+                mean_v = []
+                raw_values = res[res['method'] == method][metric]
+                values = []
+                for v in raw_values:
+                    if metric == 'CC':
+                        values.append(v[np.argmax(v)])
+                    else:
+                        values.append(v[np.argmin(v)])
+
+                if metric == 'CC':
+                    all_vals_CC.append(np.array(values))
+                if metric == 'MAE':
+                    all_vals_MAE.append(np.array(values))
+
+        for c in range(len(all_vals_CC)): #for each method
+            if avg_type == 'median':
+                curr_dataCC[c] = np.median(all_vals_CC[c])
+                curr_dataMAE[c] = np.median(all_vals_MAE[c])
+            else:
+                curr_dataCC[c] = np.mean(all_vals_CC[c])
+                curr_dataMAE[c] = np.mean(all_vals_MAE[c])
+
+        data_CC.append(curr_dataCC)
+        data_MAE.append(curr_dataMAE)
+        
+
+    elif DATASET == 'PURE':
+
+        cases = {'01':'steady', '02':'talking', '03':'slow_trans', '04':'fast_trans', '05':'small_rot', '06':'fast_rot'}
+        all_CC = {'01':[], '02':[], '03':[], '04':[], '05':[], '06':[]}
+        all_MAE = {'01':[], '02':[], '03':[], '04':[], '05':[], '06':[]}
+        CC_allcases = []
+        MAE_allcases = []
+        curr_dataCC = np.zeros(len(all_methods))
+        curr_dataMAE = np.zeros(len(all_methods))
+            
+        for metric in metrics:
+            for method in all_methods:
+                #print(method)
+                for curr_case in cases.keys():
+                    
+                    curr_res = res[res['videoName'].str.split('/').str[5].str.split('-').str[1] == curr_case]
+                    raw_values = curr_res[curr_res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+
+                    if metric == 'CC':
+                        all_CC[curr_case].append(np.array(values))
+                    if metric == 'MAE':
+                        all_MAE[curr_case].append(np.array(values))
+        
+        for curr_case in cases.keys():
+
+            all_vals_CC = all_CC[curr_case]
+            all_vals_MAE = all_MAE[curr_case]
+
+            for c in range(len(all_vals_CC)): #for each method
+                if avg_type == 'median':
+                    curr_dataCC[c] = np.median(all_vals_CC[c])
+                    curr_dataMAE[c] = np.median(all_vals_MAE[c])
+                else:
+                    curr_dataCC[c] = np.mean(all_vals_CC[c])
+                    curr_dataMAE[c] = np.mean(all_vals_MAE[c])
+
+            data_CC.append(curr_dataCC.copy())
+            data_MAE.append(curr_dataMAE.copy())
+
+    elif DATASET == 'Cohface':
+            
+        CC_allcases = []
+        MAE_allcases = []
+        curr_dataCC = np.zeros(len(all_methods))
+        curr_dataMAE = np.zeros(len(all_methods))
+
+        for metric in metrics:
+            for method in all_methods:
+                    raw_values = res[res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+                    
+                    if metric == 'CC':
+                        CC_allcases.append(np.array(values))
+                    if metric == 'MAE':
+                        MAE_allcases.append(np.array(values))
+
+        for c in range(len(CC_allcases)): #for each method
+            if avg_type == 'median':
+                curr_dataCC[c] = np.median(all_vals_CC[c])
+                curr_dataMAE[c] = np.median(all_vals_MAE[c])
+            else:
+                curr_dataCC[c] = np.mean(CC_allcases[c])
+                curr_dataMAE[c] = np.mean(MAE_allcases[c])
+
+        data_CC.append(curr_dataCC)
+        data_MAE.append(curr_dataMAE)
+
+
+    elif DATASET == 'LGI-PPGI':
+
+        cases = ['gym', 'resting', 'rotation', 'talk']
+        #cases = ['resting']
+        all_CC = {'gym':[], 'resting':[], 'rotation':[], 'talk':[]}
+        all_MAE = {'gym':[], 'resting':[], 'rotation':[], 'talk':[]}
+        CC_allcases = []
+        MAE_allcases = []
+        curr_dataCC = np.zeros(len(all_methods))
+        curr_dataMAE = np.zeros(len(all_methods))
+
+        for metric in metrics:
+            for method in all_methods:
+                #print(method)
+                for curr_case in cases:
+
+                    curr_res = res[res['videoName'].str.split('/').str[6].str.split('_').str[1] == curr_case]
+                    raw_values = curr_res[curr_res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+
+                    if metric == 'CC':
+                        all_CC[curr_case].append(np.array(values))
+                    if metric == 'MAE':
+                        all_MAE[curr_case].append(np.array(values))
+
+        for curr_case in cases:
+            all_vals_CC = all_CC[curr_case]
+            all_vals_MAE = all_MAE[curr_case]
+
+            for c in range(len(all_vals_CC)): #for each method
+                if avg_type == 'median':
+                    curr_dataCC[c] = np.median(all_vals_CC[c])
+                    curr_dataMAE[c] = np.median(all_vals_MAE[c])
+                else:
+                    curr_dataCC[c] = np.mean(all_vals_CC[c])
+                    curr_dataMAE[c] = np.mean(all_vals_MAE[c])
+
+            data_CC.append(curr_dataCC.copy())
+            data_MAE.append(curr_dataMAE.copy())
+
+
+data_CC = np.vstack(data_CC)
+data_MAE = np.vstack(data_MAE)
+n_datasets = data_CC.shape[0]
+alpha = '0.05'
+
+plt.figure()
+
+plt.subplot(1,2,1)
+plt.title('CC Multi Dataset')
+plt.boxplot(data_CC, showfliers=True)
+plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+plt.subplot(1,2,2)
+plt.title('MAE Multi Dataset')
+plt.boxplot(data_MAE, showfliers=True)
+plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+            
+from nonparametric_tests import friedman_aligned_ranks_test as ft
+import Orange
+
+data_MAE_df = pd.DataFrame(data_MAE, columns=all_methods)
+print('\nFriedman Test MAE:')
+#print(ss.friedmanchisquare(*data_MAE.T))
+#print(' ')
+t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+avranksMAE = list(np.divide(ranks_mae, n_datasets))
+
+print('statistic: ' + str(t))
+print('pvalue: ' + str(p))
+print(' ')
+pc = sp.posthoc_nemenyi_friedman(data_MAE_df)
+cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+
+plt.figure()
+sp.sign_plot(pc, **heatmap_args)
+plt.title('Nemenyi Test MAE')
+
+
+data_CC_df = pd.DataFrame(data_CC, columns=all_methods)
+print('\nFriedman Test CC:')
+#print(ss.friedmanchisquare(*data_CC.T))
+#print(' ')
+t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], data_CC[:,4], data_CC[:,5], data_CC[:,6], data_CC[:,7])
+avranksCC = list(np.divide(ranks_cc, n_datasets))
+
+print('statistic: ' + str(t))
+print('pvalue: ' + str(p))
+print(' ')
+pc = sp.posthoc_nemenyi_friedman(data_CC_df)
+cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+
+plt.figure()
+sp.sign_plot(pc, **heatmap_args)
+plt.title('Nemenyi Test CC')
+
+cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+plt.title('CD Diagram MAE')
+
+cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+plt.title('CD Diagram CC')
+
+print(data_MAE_df)
+print(' ')
+print(data_CC_df)
+
+plt.show()

nonparametric_tests.py

@@ -0,0 +1,678 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import scipy as sp
+import scipy.stats as st
+import itertools as it
+
+
+def binomial_sign_test(*args):
+    """
+        Performs a binomial sign test for two dependent samples.
+        Tests the hypothesis that the two dependent samples represent two different populations.
+        
+        Parameters
+        ----------
+        sample1, sample2: array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        B-value : float
+            The computed B-value of the test.
+        p-value : float
+            The associated p-value from the B-distribution.
+            
+        References
+        ----------
+        D.J. Sheskin, Handbook of parametric and nonparametric statistical procedures. crc Press, 2003, Test 19: The Binomial Sign Test for Two Dependent Samples
+    """
+    k = len(args)
+    if k != 2: raise ValueError('The test needs two samples')
+    n = len(args[0])
+    
+    d_plus = 0
+    d_minus = 0
+    for i in range(n):
+        # Zero differences are eliminated
+        if args[0][i] < args[1][i]: 
+            d_plus = d_plus+1
+        elif args[0][i] > args[1][i]:
+            d_minus = d_minus+1
+    
+    x = max(d_plus, d_minus)
+    n = d_plus + d_minus
+    
+    p_value = 2*(1 - st.binom.cdf(x, n, 0.5)) # Two-tailed of the smallest p-value
+    
+    return x, p_value
+    
+        
+
+def friedman_test(*args):
+    """
+        Performs a Friedman ranking test.
+        Tests the hypothesis that in a set of k dependent samples groups (where k >= 2) 
+        at least two of the groups represent populations with different median values.
+        
+        Parameters
+        ----------
+        sample1, sample2, ... : array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        F-value : float
+            The computed F-value of the test.
+        p-value : float
+            The associated p-value from the F-distribution.
+        rankings : array_like
+            The ranking for each group.
+        pivots : array_like
+            The pivotal quantities for each group.
+            
+        References
+        ----------
+        M. Friedman, The use of ranks to avoid the assumption of normality implicit in the 
+        analysis of variance, Journal of the American Statistical Association 32 (1937) 674–701.
+        D.J. Sheskin, Handbook of parametric and nonparametric statistical procedures. 
+        crc Press, 2003, Test 25: The Friedman Two-Way Analysis of Variance by Ranks
+    """
+    k = len(args)
+    if k < 2: raise ValueError('Less than 2 levels')
+    n = len(args[0])
+    if len(set([len(v) for v in args])) != 1: raise ValueError('Unequal number of samples')
+
+    rankings = []
+    for i in range(n):
+        row = [col[i] for col in args]
+        row_sort = sorted(row)
+        rankings.append([row_sort.index(v) + 1 + (row_sort.count(v)-1)/2. for v in row])
+
+    rankings_avg = [sp.mean([case[j] for case in rankings]) for j in range(k)]
+    rankings_cmp = [r/sp.sqrt(k*(k+1)/(6.*n)) for r in rankings_avg]
+
+    chi2 = ((12*n)/float((k*(k+1))))*((sp.sum(r**2 for r in rankings_avg))-((k*(k+1)**2)/float(4)))
+    iman_davenport = ((n-1)*chi2)/float((n*(k-1)-chi2))
+
+    p_value = 1 - st.f.cdf(iman_davenport, k-1, (k-1)*(n-1))
+
+    return iman_davenport, p_value, rankings_avg, rankings_cmp
+
+
+
+def friedman_aligned_ranks_test(*args):
+    """
+        Performs a Friedman aligned ranks ranking test.
+        Tests the hypothesis that in a set of k dependent samples groups 
+        (where k >= 2) at least two of the groups represent populations 
+        with different median values.
+        The difference with a friedman test is that it uses the median of 
+        each group to construct the ranking, which is useful when the number 
+        of samples is low.
+        
+        Parameters
+        ----------
+        sample1, sample2, ... : array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        Chi2-value : float
+            The computed Chi2-value of the test.
+        p-value : float
+            The associated p-value from the Chi2-distribution.
+        rankings : array_like
+            The ranking for each group.
+        pivots : array_like
+            The pivotal quantities for each group.
+            
+        References
+        ----------
+         J.L. Hodges, E.L. Lehmann, Ranks methods for combination of independent 
+         experiments in analysis of variance, Annals of Mathematical Statistics 33 (1962) 482–497.
+    """
+    
+    
+    k = len(args)
+    
+    if k < 2: raise ValueError('Less than 2 levels')
+    n = len(args[0])
+    
+    if len(set([len(v) for v in args])) != 1: raise ValueError('Unequal number of samples')
+
+    aligned_observations = []
+    for i in range(n):
+        loc = sp.mean([col[i] for col in args])
+        aligned_observations.extend([col[i] - loc for col in args])
+        
+    aligned_observations_sort = sorted(aligned_observations)
+    
+    aligned_ranks = []
+    for i in range(n):
+        row = []
+        for j in range(k):
+            v = aligned_observations[i*k+j]
+            row.append(aligned_observations_sort.index(v) + 1 + (aligned_observations_sort.count(v)-1)/2.)
+        aligned_ranks.append(row)
+
+    rankings_avg = [sp.mean([case[j] for case in aligned_ranks]) for j in range(k)]
+    rankings_cmp = [r/sp.sqrt(k*(n*k+1)/6.) for r in rankings_avg]
+
+    r_i = [np.sum(case) for case in aligned_ranks]
+    r_j = [np.sum([case[j] for case in aligned_ranks]) for j in range(k)]
+    T = (k-1) * (sp.sum(v**2 for v in r_j) - (k*n**2/4.) * (k*n+1)**2) / float(((k*n*(k*n+1)*(2*k*n+1))/6.) - (1./float(k))*sp.sum(v**2 for v in r_i))
+
+    p_value = 1 - st.chi2.cdf(T, k-1)
+
+    return T, p_value, rankings_avg, rankings_cmp
+
+
+
+def quade_test(*args):
+    """
+        Performs a Quade ranking test.
+        Tests the hypothesis that in a set of k dependent samples groups (where k >= 2) at least two of the groups represent populations with different median values.
+        The difference with a friedman test is that it uses the median for each sample to wiehgt the ranking.
+        
+        Parameters
+        ----------
+        sample1, sample2, ... : array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        F-value : float
+            The computed F-value of the test.
+        p-value : float
+            The associated p-value from the F-distribution.
+        rankings : array_like
+            The ranking for each group.
+        pivots : array_like
+            The pivotal quantities for each group.
+            
+        References
+        ----------
+        D. Quade, Using weighted rankings in the analysis of complete blocks with additive block effects, Journal of the American Statistical Association 74 (1979) 680–683.
+    """
+    k = len(args)
+    if k < 2: raise ValueError('Less than 2 levels')
+    n = len(args[0])
+    if len(set([len(v) for v in args])) != 1: raise ValueError('Unequal number of samples')
+
+    rankings = []
+    ranges = []
+    for i in range(n):
+        row = [col[i] for col in args]
+        ranges.append(max(row) - min(row))
+        row_sort = sorted(row)
+        rankings.append([row_sort.index(v) + 1 + (row_sort.count(v)-1)/2. for v in row])
+   
+    ranges_sort = sorted(ranges)
+    ranking_cases = [ranges_sort.index(v) + 1 + (ranges_sort.count(v)-1)/2. for v in ranges]
+
+    S = []
+    W = []
+    for i in range(n):
+        S.append([ranking_cases[i] * (r - (k + 1)/2.) for r in rankings[i]])
+        W.append([ranking_cases[i] * r for r in rankings[i]])
+
+    Sj = [np.sum(row[j] for row in S) for j in range(k)]
+    Wj = [np.sum(row[j] for row in W) for j in range(k)]
+    
+    rankings_avg = [w / (n*(n+1)/2.) for w in Wj]
+    rankings_cmp = [r/sp.sqrt(k*(k+1)*(2*n+1)*(k-1)/(18.*n*(n+1))) for r in rankings_avg]
+
+    A = sp.sum(S[i][j]**2 for i in range(n) for j in range(k))
+    B = sp.sum(s**2 for s in Sj)/float(n)
+    F = (n-1)*B/(A-B)
+
+    p_value = 1 - st.f.cdf(F, k-1, (k-1)*(n-1))
+
+    return F, p_value, rankings_avg, rankings_cmp
+
+def bonferroni_dunn_test(ranks, control=None):
+    """
+        Performs a Bonferroni-Dunn post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method (one vs all), default None (all vs all) 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. Dunn, Multiple comparisons among means, Journal of the American Statistical Association 56 (1961) 52–64.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min((k-1)*p_value,1) for p_value in p_values]
+    
+    return comparisons, z_values, p_values, adj_p_values
+    
+    
+def holm_test(ranks, control=None):
+    """
+        Performs a Holm post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method (one vs all), default None (all vs all) 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. S. Holm, A simple sequentially rejective multiple test procedure, Scandinavian Journal of Statistics 6 (1979) 65–70.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max((k-(j+1))*p_values[j] for j in range(i+1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+    
+    
+def hochberg_test(ranks, control=None):
+    """
+        Performs a Hochberg post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Y. Hochberg, A sharper Bonferroni procedure for multiple tests of significance, Biometrika 75 (1988) 800–803.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max((k-j)*p_values[j-1] for j in range(k-1, i, -1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def li_test(ranks, control=None):
+    """
+        Performs a Li post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        J. Li, A two-step rejection procedure for testing multiple hypotheses, Journal of Statistical Planning and Inference 138 (2008) 1521–1527.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [p_values[i]/(p_values[i]+1-p_values[-1]) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def finner_test(ranks, control=None):
+    """
+        Performs a Finner post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        H. Finner, On a monotonicity problem in step-down multiple test procedures, Journal of the American Statistical Association 88 (1993) 920–923.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max(1-(1-p_values[j])**((k-1)/float(j+1)) for j in range(i+1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+
+def nemenyi_multitest(ranks):
+    """
+        Performs a Nemenyi post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Bonferroni-Dunn: O.J. Dunn, Multiple comparisons among means, Journal of the American Statistical Association 56 (1961) 52–64.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(m*p_value,1) for p_value in p_values]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+
+def holm_multitest(ranks):
+    """
+        Performs a Holm post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. S. Holm, A simple sequentially rejective multiple test procedure, Scandinavian Journal of Statistics 6 (1979) 65–70.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(max((m-j)*p_values[j] for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+
+def hochberg_multitest(ranks):
+    """
+        Performs a Hochberg post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Y. Hochberg, A sharper Bonferroni procedure for multiple tests of significance, Biometrika 75 (1988) 800–803.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [max((m+1-j)*p_values[j-1] for j in range(m, i, -1))for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+    
+
+def finner_multitest(ranks):
+    """
+        Performs a Finner post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        H. Finner, On a monotonicity problem in step-down multiple test procedures, Journal of the American Statistical Association 88 (1993) 920–923.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(max(1-(1-p_values[j])**(m/float(j+1)) for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+
+def _S(k):
+    """
+        Helper function for the Shaffer test.
+        It obtains the number of independent test hypotheses when using an All vs All strategy using the number of groups to be compared.
+    """
+    if k == 0 or k == 1:
+        return {0}
+    else:
+        result = set()
+        for j in reversed(range(1, k+1)):
+            tmp = S(k - j)
+            for s in tmp:
+                result = result.union({sp.special.binom(j, 2) + s})
+        return list(result)
+
+
+def shaffer_multitest(ranks):
+    """
+        Performs a Shaffer post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        J. Li, A two-step rejection procedure for testing multiple hypotheses, Journal of Statistical Planning and Inference 138 (2008) 1521–1527.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+    
+    m = int(k*(k-1)/2.)
+    A = _S(int((1 + sp.sqrt(1+4*m*2))/2))
+    t = [max([a for a in A if a <= m-i]) for i in range(m)]
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max(t[j]*p_values[j] for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values

pbv.py

@@ -0,0 +1,27 @@
+import numpy as np
+from scipy import signal
+from .base import VHRMethod
+
+class PBV(VHRMethod):
+    methodName = 'PBV'
+    
+    def __init__(self, **kwargs):
+        super(PBV, self).__init__(**kwargs)
+        
+    def apply(self, X):
+        
+        r_mean = X[0,:]/np.mean(X[0,:])
+        g_mean = X[1,:]/np.mean(X[1,:])
+        b_mean = X[2,:]/np.mean(X[2,:])
+
+        pbv_n = np.array([np.std(r_mean), np.std(g_mean), np.std(b_mean)])
+        pbv_d = np.sqrt(np.var(r_mean) + np.var(g_mean) + np.var(b_mean))
+        pbv = pbv_n / pbv_d
+
+        C = np.array([r_mean, g_mean, b_mean])
+        Q = np.matmul(C ,np.transpose(C))
+        W = np.linalg.solve(Q,pbv)
+
+        bvp = np.matmul(C.T,W)/(np.matmul(pbv.T,W)) 
+
+        return bvp

pca.py

@@ -0,0 +1,39 @@
+from sklearn import decomposition
+from numpy import vstack
+from .base import VHRMethod
+
+class PCA(VHRMethod):
+    methodName = 'PCA'
+    
+    def __init__(self, **kwargs):
+        super(PCA, self).__init__(**kwargs)
+
+    def apply(self, X):
+        
+        # TODO: preproc
+        #X = self.__preprocess(X.T)
+
+        bvp = decomposition.PCA(n_components=3).fit_transform(X.T).T
+
+        return bvp
+
+
+    def __preprocess(self, X):
+        
+        R = X[:,0].copy()
+        G = X[:,1].copy()
+        B = X[:,2].copy()
+
+        # -- BP pre-filtering of RGB channels
+        minHz = BVPsignal.minHz
+        maxHz = BVPsignal.maxHz
+        fs = self.video.frameRate
+
+        # -- filter
+        filteredR = BPfilter(R, minHz, maxHz, fs)
+        filteredG = BPfilter(G, minHz, maxHz, fs)
+        filteredB = BPfilter(B, minHz, maxHz, fs)
+
+        X = vstack([filteredR, filteredG, filteredB])
+
+        return X

pos.py

@@ -0,0 +1,47 @@
+import numpy as np
+from scipy import signal
+from .base import VHRMethod
+
+class POS(VHRMethod):
+    """  
+        POS algorithm described in "Algorithmic Principles of Remote PPG"
+        (https://ieeexplore.ieee.org/document/7565547 )
+        Numbers in brackets refer to the line numbers in the "Algorithm 1" of the paper
+    """
+    
+    methodName = 'POS'
+    projection = np.array([[0, 1, -1], [-2, 1, 1]])
+
+    def __init__(self, **kwargs):
+        super(POS, self).__init__(**kwargs)
+
+    def apply(self, X):
+        # Run the pos algorithm on the RGB color signal c with sliding window length wlen
+        # Recommended value for wlen is 32 for a 20 fps camera (1.6 s)
+        
+        wlen = int(1.6*self.video.frameRate)
+
+        # Initialize (1)
+        h = np.zeros(X.shape[1])
+        for n in range(X.shape[1]):
+            # Start index of sliding window (4)
+            m = n - wlen + 1
+            if m >= 0:
+                # Temporal normalization (5)
+                cn = X[:, m:(n+1)]
+                cn = np.dot(self.__get_normalization_matrix(cn), cn)
+                # Projection (6)
+                s = np.dot(self.projection, cn)
+                # Tuning (7)
+                hn = np.add(s[0, :], np.std(s[0, :])/np.std(s[1, :])*s[1, :])
+                # Overlap-adding (8)
+                h[m:(n+1)] = np.add(h[m:(n+1)], hn - np.mean(hn))
+        return h
+
+
+    def __get_normalization_matrix(self, x):
+        # Compute a diagonal matrix n such that the mean of n*x is a vector of ones
+        d = 0 if (len(x.shape) < 2) else 1
+        m = np.mean(x, d)
+        n = np.array([[1/m[i] if i == j and m[i] else 0 for i in range(len(m))] for j in range(len(m))])
+        return n

printutils.py

@@ -0,0 +1,66 @@
+import plotly.graph_objects as go
+import numpy as np
+
+# Print iterations progress
+def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█', printEnd = "\r"):
+    """
+    Call in a loop to create terminal progress bar
+    @params:
+        iteration   - Required  : current iteration (Int)
+        total       - Required  : total iterations (Int)
+        prefix      - Optional  : prefix string (Str)
+        suffix      - Optional  : suffix string (Str)
+        decimals    - Optional  : positive number of decimals in percent complete (Int)
+        length      - Optional  : character length of bar (Int)
+        fill        - Optional  : bar fill character (Str)
+        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
+    """
+    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
+    filledLength = int(length * iteration // total)
+    bar = fill * filledLength + '-' * (length - filledLength)
+    print('\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix), end = printEnd)
+    # Print New Line on Complete
+    if iteration == total: 
+        print()
+        
+        
+def multiplot(x=None, y=None, name=None, zeroMean=True, title="Signal", height=400, width=800):
+
+    fig = go.Figure()
+
+    if not np.any(y):
+        return
+    else:
+        if y.ndim == 1:
+            c = 1
+            n = y.shape[0]
+            if zeroMean:
+                z = y-y.mean()
+            if not np.any(x):
+                x = np.linspace(0,n-1,n)
+            fig.add_trace(go.Scatter(x=x,y=z,name=name))
+        else:
+            c,n = y.shape
+            if not np.any(x):
+                x = np.linspace(0,n-1,n)
+            for i in range(c):
+                z = y[i] 
+                if name:
+                    s = name[i]
+                else:
+                    s = "sig" + str(i)
+                if zeroMean:
+                    z = y[i]-y[i].mean()
+                    
+                fig.add_trace(go.Scatter(x=x,y=z,name=s))
+    
+    fig.update_layout(height=height, width=width, title=title,
+        font=dict(
+            family="Courier New, monospace",
+            size=14,
+            color="#7f7f7f")
+    )
+
+    fig.show()
+    
+    return fig

pure.py

@@ -0,0 +1,74 @@
+import json
+import numpy as np
+import os
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class PURE(Dataset):
+    """
+    PURE dataset structure:
+    -----------------
+        datasetDIR/
+        |
+        |-- 01-01/
+        |---- Image...1.png
+        |---- Image.....png
+        |---- Image...n.png
+        |-- 01-01.json
+        |...
+        |...
+        |-- nn-nn/
+        |---- Image...1.png
+        |---- Image.....png
+        |---- Image...n.png        
+        |-- nn-nn.json
+        |...
+    """
+    name = 'PURE'
+    signalGT = 'BVP'      # GT signal type
+    numLevels = 1         # depth of the filesystem collecting video and BVP files
+    numSubjects = 10      # number of subjects
+    video_EXT = 'png'     # extension of the video files
+    frameRate = 30        # vieo frame rate
+    VIDEO_SUBSTRING = '-' # substring contained in the filename
+    SIG_EXT = 'json'      # extension of the BVP files
+    SIG_SUBSTRING = '-'   # substring contained in the filename
+    SIG_SampleRate = 60   # sample rate of the BVP files
+    skinThresh = [40,60]  # thresholds for skin detection
+
+    def readSigfile(self, filename):
+        """ Load BVP signal.
+            Must return a 1-dim (row array) signal
+        """
+        bvp = []
+        with open(filename) as json_file:
+            json_data = json.load(json_file)
+            for p in json_data['/FullPackage']:
+                bvp.append(p['Value']['waveform'])
+
+        data = np.array(bvp)
+
+        return BVPsignal(data, self.SIG_SampleRate)
+
+
+    def loadFilenames(self):
+        """
+        Load dataset file names and directories of frames: 
+        define vars videoFilenames and BVPFilenames
+        """
+
+        # -- loop on the dir struct of the dataset getting directories and filenames
+        for root, dirs, files in os.walk(self.videodataDIR):
+
+            for f in files:
+                filename = os.path.join(root, f)
+                path, name = os.path.split(filename)
+                
+                # -- select signal
+                if name.endswith(self.SIG_EXT) and (name.find(self.SIG_SUBSTRING)>=0):
+                    self.sigFilenames.append(filename)
+                    self.videoFilenames.append(filename[:-5] + '/file.' + self.video_EXT)
+
+        # -- number of videos
+        self.numVideos = len(self.videoFilenames)
+

pyramid.py

@@ -0,0 +1,122 @@
+import numpy as np
+import cv2
+#import scipy.fftpack as fftpack
+import scipy
+
+
+def gaussian_video(video, pyramid_levels):
+    """Create a gaussian representation of a video"""
+    vid_data = None
+    for x in range(0, video.shape[0]):
+        frame = video[x]
+        gauss_copy = np.ndarray(shape=frame.shape, dtype="float")
+        gauss_copy[:] = frame
+        for i in range(pyramid_levels):
+            gauss_copy = gausPyrDown(gauss_copy)
+        if x == 0:
+            vid_data = np.zeros((video.shape[0], gauss_copy.shape[0], gauss_copy.shape[1], 3))
+        vid_data[x] = gauss_copy
+    return vid_data
+
+def gausPyrDown(frame,sz=5,sigma=1):
+    height, width, channel = frame.shape
+    convFrame = np.zeros(shape=(height, width,channel), dtype="float")
+    kernel = gausKernel(sz=sz,sigma=sigma)
+    for channel_i in range(channel):
+        convFrame[:,:,channel_i] = scipy.ndimage.convolve(frame[:,:,channel_i],kernel)
+    downFrame = convFrame[::2,::2,:]
+    return downFrame
+
+def gausPyrUp(frame,sz=5,sigma=1):
+    height, width, channel = frame.shape
+    upFrame = np.zeros(shape=(2*height, 2*width,channel), dtype="float")
+    kernel = gausKernel(sz=sz,sigma=sigma)
+    for channel_i in range(channel):
+        upFrame[::2,::2,channel_i] = frame[:,:,channel_i]
+        upFrame[:,:,channel_i] = scipy.ndimage.convolve(upFrame[:,:,channel_i],kernel*4)
+    return upFrame
+
+# Define the Gaussian kernel
+def gausKernel(sz = 5,sigma=1):
+    kernel = np.zeros((sz,sz))
+    ### STUDENT: Implement the Gaussian kernel
+    sz_1 = int(sz/2)
+    for x in (np.arange(sz)-sz_1):
+        for y in (np.arange(sz)-sz_1):
+            ix,iy = x+sz_1,y+sz_1
+            kernel[ix,iy] = np.exp(-(x**2+y**2)/(2.0*sigma**2))
+    kernel = kernel / np.sum(kernel)
+    ### STUDENT END
+    return kernel
+
+# We will use your previously implemented temporal bandpass filter, so make sure it works！
+def temporal_bandpass_filter(data, fps, freq_min=0.833, freq_max=1, axis=0):
+    # Inputs:
+    # data: video data of shape #frames x height x width x #channel (3,RGB)
+    # fps: frames per second (30)
+    # freq_min, freq_max: cut-off frequencies for bandpass filter
+    # axis: dimension along which to apply FFT (default:0, 
+    #       time domain <->for a single pixel along all frames)
+    # Output:
+    #        Band-passed video data, with only frequency components (absolute value) 
+    #        between freq_min and freq_max preserved
+    #        of shape #frames x height x width x #channel (3,RGB)
+    data_process = np.zeros(data.shape)
+    sample_interval = 1.0/fps
+    for x in range(data.shape[1]):
+        for y in range(data.shape[2]):
+            for z in range(data.shape[3]):
+                # the bandpass_filter is YOUR implementation!
+                data_process[:,x,y,z] = bandpass_filter(data[:,x,y,z], sample_interval, freq_min, freq_max)
+    return data_process
+
+
+
+# Implement the temporal bandpass filter
+def bandpass_filter(x, sample_interval, freq_min, freq_max):
+    # Inputs:
+    # x: temporal signal of shape (N,)
+    # sample_interval: the temporal sampling interval.
+    # freq_min, freq_max: cut-off frequencies for bandpass filter
+    # Output:
+    # Band-passed signal, with only frequency components (absolute value) 
+    #      between freq_min and freq_max  preserved
+
+    ### STUDENT: Implement the bandpass filter. 
+    ### Feel free to use numpy.fft.fft, numpy.fft.fftfreq, numpy.fft.ifft
+    X = np.fft.fft(x)
+    frequencies = np.fft.fftfreq(len(x), d=sample_interval)
+    bound_low = (np.abs(frequencies - freq_min)).argmin()
+    bound_high = (np.abs(frequencies - freq_max)).argmin()
+    X[:bound_low] = 0
+    X[bound_high:-bound_high] = 0
+    X[-bound_low:] = 0
+    band_pass_signal = np.abs(np.fft.ifft(X, axis=0))
+    ### STUDENT END
+    return band_pass_signal
+
+
+# Utility function: used to convert numpy array to comform with video format
+def convertScaleAbs(frame):
+    outFrame = np.ndarray(shape=frame.shape, dtype="uint8")
+    for channel_i in range(3):
+        outFrame[:,:,channel_i] = np.clip(np.abs(frame[:,:,channel_i]),0,255).astype(np.uint8).copy()
+    return outFrame
+
+
+def combine_pyramid_and_save(g_video, orig_video, enlarge_multiple, fps):
+    """Combine a gaussian video representation with the original"""
+    
+    width, height = orig_video.shape[2], orig_video.shape[1]
+    mag_data = np.zeros(orig_video.shape, dtype='uint8')
+    for x in range(0, g_video.shape[0]):
+        img = np.ndarray(shape=g_video[x].shape, dtype='float')
+        img[:] = g_video[x]
+        for i in range(enlarge_multiple):
+            img = gausPyrUp(img)
+        img[:height, :width] = img[:height, :width] + orig_video[x]
+        res = convertScaleAbs(img[:height, :width])
+        mag_data[x] = res
+    return mag_data
+
+

sample.cfg

@@ -0,0 +1,69 @@
+# default_test.cfg - default test configuration file for TestSuite class
+
+## Default parameters
+#
+#  winsize   = Duration of the time window to process the video (in seconds)
+#  winsizeGT = Duration of the time window to process the ground truth signal (in seconds)
+#  timeStep  = Time step of the estimation (in seconds)
+#  methods   = A list of methods to test (['CHROM','Green','ICA','LGI','PBV','PCA','POS','SSR'])
+#
+## Video signal Preprocessing
+#
+#  zeroMeanSTDnorm = Apply Zero Mean and Unit Standard Deviation (0/1)
+#  detrending      = Apply detrenting algorithm (0/1)
+#  detrMethod      = Detrenting algorithm (tarvainen/scipy)
+#  detLambda       = If detrending = 1, regularization parameter of detrending algorithm
+#  BPfilter        = Apply band pass filtering (0/1)
+#  minHz           = If BPfilter = 1, the lower cut-off frequency (in hertz)
+#  maxHz           = If BPfilter = 1, the upper cut-off frequency (in hertz)
+
+[DEFAULT]
+winSize         = 5
+winSizeGT       = 5
+timeStep        = 1
+methods         = ['POS','CHROM']
+zeroMeanSTDnorm = 0
+detrending      = 0
+detLambda       = 10
+BPfilter        = 1
+minHz           = 0.75
+maxHz           = 4.0
+
+## Video signal
+#
+#  dataset      = Name of the dataset to test ('PURE', 'UBFC1', 'UBFC2', 'LGI-PPGI', 'COHFACE', 'MAHNOB')
+#  videoIdx     = A list of IDs reffered to the videos to test (eg. [0,1,2,...]) 
+#                 or the string 'all' to test on the whole database
+#  detector     = Method used for face detection (mtcnn, dlib, mtcnn_kalman)
+#  extractor    = Preferred library to read video files (opencv/skvideo)
+#  startTime    = Process video file from  start time (in seconds)
+#  endTime      = Process video file until end time (in seconds). If < 0: process until (video length - endTime) 
+
+[VIDEO]
+dataset     = lgi_ppgi
+videodataDIR= ../sampleDataset/
+BVPdataDIR  = ../sampleDataset/
+videoIdx    = [0]
+detector    = mtcnn
+extractor   = skvideo
+startTime   = 3
+endTime     = -3
+ROImask = skin_fix
+skinFix   = [40, 60]
+skinAdapt = 0.2
+rectCoords= [[0, 0, 150, 150]]
+evm = 0
+stat = mean
+
+## Method specific configurations
+
+[CHROM]
+zeroMeanSTDnorm = 0
+detrending      = 1
+detrMethod      = scipy
+BPfilter        = 0
+
+[POS]
+zeroMeanSTDnorm = 0
+detrending      = 0
+BPfilter        = 0

sample.py

@@ -0,0 +1,58 @@
+import xml.etree.ElementTree as ET
+import numpy as np
+from os import path
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class SAMPLE(Dataset):
+    """
+    Sample dataset structure:
+    -----------------
+        datasetDIR/
+        |
+        |-- videoSample.avi
+        |-- signalGT.xml
+    """
+    name = 'SAMPLE'
+    videodataDIR = '../sampleDataset/'  # path relative to notebook dir in pyVHR filesystem on GitHub
+    BVPdataDIR = '../sampleDataset/'    # path relative to notebook dir in pyVHR filesystem on GitHub
+    signalGT = 'BVP'          # GT signal type
+    numLevels = 1             # depth of the filesystem collecting video and BVP files
+    numSubjects = 4           # number of subjects
+    video_EXT = 'avi'         # extension of the video files
+    frameRate = 25            # vieo frame rate
+    VIDEO_SUBSTRING = 'cv_camera' # substring contained in the filename
+    SIG_EXT = 'xml'           # extension of the BVP files
+    SIG_SUBSTRING = 'cms50'      # substring contained in the filename
+    SIG_SampleRate = 60       # sample rate of the BVP files
+
+    def readSigfile(self, filename):
+        """
+            Load BVP signal. Must return a 1-dim (row array) signal
+        """
+
+        tree = ET.parse(filename)
+        # get all bvp elements and their values
+        bvp_elements = tree.findall('.//*/value2')
+        bvp = [int(item.text) for item in bvp_elements]
+        
+        n_bvp_samples = len(bvp)
+        last_bvp_time = int((n_bvp_samples*1000)/self.SIG_SampleRate)
+
+        vid_xml_filename = path.join(path.dirname(filename), 'cv_camera_sensor_timer_stream_handler.xml')
+        tree = ET.parse(vid_xml_filename)
+        
+        root = tree.getroot()
+        last_vid_time = int(float(root[-1].find('value1').text))
+
+        diff = ((last_bvp_time - last_vid_time)/1000)
+
+        assert diff >= 0, 'Unusable data.'
+
+        print("Skipping %.2f seconds..." % diff)
+
+        diff_samples = round(diff*self.SIG_SampleRate)
+
+        data = np.array(bvp[diff_samples:])
+
+        return BVPsignal(data, self.SIG_SampleRate)

shape_predictor_5_face_landmarks.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4b1e9804792707d3a405c2c16a80a20269e6675021f64a41d30fffafbc41888
+size 9150489

shape_predictor_68_face_landmarks.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbdc2cb80eb9aa7a758672cbfdda32ba6300efe9b6e6c7a299ff7e736b11b92f
+size 99693937

single_dataset_analysis.py

@@ -0,0 +1,501 @@
+import sys
+sys.path.append("..")
+import pandas as pd
+import numpy as np
+import os
+import re 
+import matplotlib.pyplot as plt
+import scipy.stats as ss
+import scikit_posthocs as sp
+import pandas as pd
+from nonparametric_tests import friedman_aligned_ranks_test as ft
+import Orange
+
+def sort_nicely(l): 
+    """ Sort the given list in the way that humans expect. 
+    """ 
+    convert = lambda text: int(text) if text.isdigit() else text 
+    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] 
+    l.sort( key=alphanum_key ) 
+
+    return l
+
+#Dataset on which perform analysis
+#DATASET = 'LGI-PPGI'
+#DATASET = 'PURE'
+DATASET = 'UBFC1'
+#DATASET = 'UBFC2'
+#DATASET = 'Cohface'
+#DATASET = 'Mahnob'
+#DATASET = 'UBFC_ALL'
+
+CASE = 'full'
+#CASE = 'split'
+
+alpha = '0.05'
+
+if DATASET == 'UBFC_ALL':
+    exp_path1 = '../../results/' + 'UBFC1' + '/'
+    files1 = sort_nicely(os.listdir(exp_path1))
+    exp_path2 = '../../results/' + 'UBFC2' + '/'
+    files2 = sort_nicely(os.listdir(exp_path2))
+else:
+    #Experiment Path
+    exp_path = '../../results/' + DATASET + '/'
+    files = sort_nicely(os.listdir(exp_path))
+
+#All rPPG methods used
+all_methods = ['CHROM','Green','ICA','LGI','PBV','PCA','POS','SSR']
+
+#Method(s) for the visualization of the performance vs winSize
+#methods = ['POS', 'CHROM', 'LGI']
+
+#Metrics to Visualize
+#metrics = ['CC', 'MAE', 'RMSE']
+metrics = ['MAE']
+
+
+print(all_methods)
+
+#---------------- Produce Box plots for each method on a given dataset -----------
+
+win_to_use = 10
+
+if DATASET == 'UBFC_ALL':
+    f_to_use = [i for i in files1 if 'winSize'+str(win_to_use) in i][0]
+    path = exp_path1 + f_to_use
+    res1 = pd.read_hdf(path)
+    f_to_use = [i for i in files2 if 'winSize'+str(win_to_use) in i][0]
+    path = exp_path2 + f_to_use
+    res2 = pd.read_hdf(path)
+    res = res1.append(res2)
+else:
+    f_to_use = [i for i in files if 'winSize'+str(win_to_use) in i][0]
+    path = exp_path + f_to_use
+    res = pd.read_hdf(path)
+
+print('\n\n\t\t' + DATASET + '\n\n')
+
+if DATASET == 'UBFC1' or DATASET == 'UBFC2' or DATASET == 'Mahnob' or DATASET == 'UBFC_ALL' or DATASET == 'Cohface':
+
+    all_vals_CC = []
+    all_vals_MAE = []
+    all_vals_RMSE = []
+    
+    for metric in metrics:
+        for method in all_methods:
+            #print(method)
+            mean_v = []
+            raw_values = res[res['method'] == method][metric]
+            print(raw_values)
+            values = []
+            for v in raw_values:
+                
+               
+                
+                if metric == 'CC':
+                    values.append(v[np.argmax(v)])
+                else:
+                    values.append(v[np.argmin(v)])
+
+            if metric == 'CC':
+                all_vals_CC.append(np.array(values))
+            if metric == 'MAE':
+                all_vals_MAE.append(np.array(values))
+
+              
+    
+    
+    data_MAE = np.zeros([len(all_vals_MAE[0]), len(all_vals_MAE)])
+    for i,m in enumerate(all_vals_MAE):
+        data_MAE[:,i] = m
+        
+    print(data_MAE)
+    
+    '''data_MAE_df = pd.DataFrame(data_MAE, columns=all_methods)
+    print('\nFriedman Test MAE:')
+    print(ss.friedmanchisquare(*data_MAE.T))
+    print(' ')'''
+
+    '''pc = sp.posthoc_nemenyi_friedman(data_MAE_df)
+    cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+    heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+    plt.figure()
+    sp.sign_plot(pc, **heatmap_args)
+    plt.title('Nemenyi Test MAE')'''
+
+    n_datasets = data_MAE.shape[0]
+
+    t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], 
+                               data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+    avranksMAE = list(np.divide(ranks_mae, n_datasets))
+    print('statistic: ' + str(t))
+    print('pvalue: ' + str(p))
+    print(' ')
+
+    data_CC = np.zeros([len(all_vals_CC[0]), len(all_vals_CC)])
+    for i,m in enumerate(all_vals_CC):
+        data_CC[:,i] = m
+    
+    '''data_CC_df = pd.DataFrame(data_CC, columns=all_methods)
+    print('\nFriedman Test MAE:')
+    print(ss.friedmanchisquare(*data_CC.T))
+    print(' ')
+    pc = sp.posthoc_nemenyi_friedman(data_CC_df)
+    cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+    heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+    plt.figure()
+    sp.sign_plot(pc, **heatmap_args)
+    plt.title('Nemenyi Test CC')'''
+
+    t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], data_CC[:,4], 
+                             data_CC[:,5], data_CC[:,6], data_CC[:,7])
+    avranksCC = list(np.divide(ranks_cc, n_datasets))
+    print('statistic: ' + str(t))
+    print('pvalue: ' + str(p))
+    print(' ')
+
+    #plt.figure()
+    #plt.subplot(1,2,1)
+    #plt.title('CC')
+    #plt.boxplot(all_vals_CC, showfliers=False)
+    #plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+    #plt.subplot(1,2,2)
+    #plt.title('MAE')
+    #plt.boxplot(all_vals_MAE, showfliers=False)
+    #plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+    cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+    Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+    #plt.title('CD Diagram MAE')
+
+    cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+    Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+    #plt.title('CD Diagram CC')
+
+    #plt.show()
+
+elif DATASET == 'PURE':
+
+    cases = {'01':'steady', '02':'talking', '03':'slow_trans', '04':'fast_trans', '05':'small_rot', '06':'fast_rot'}
+    all_CC = {'01':[], '02':[], '03':[], '04':[], '05':[], '06':[]}
+    all_MAE = {'01':[], '02':[], '03':[], '04':[], '05':[], '06':[]}
+
+    if CASE == 'split':
+        
+        for metric in metrics:
+            for method in all_methods:
+                #print(method)
+                for curr_case in cases.keys():
+                    
+                    curr_res = res[res['videoName'].str.split('/').str[5].str.split('-').str[1] == curr_case]
+                    raw_values = curr_res[curr_res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+
+                    if metric == 'CC':
+                        all_CC[curr_case].append(np.array(values))
+                    if metric == 'MAE':
+                        all_MAE[curr_case].append(np.array(values))
+
+        for curr_case in cases.keys():
+            '''plt.figure()
+
+            plt.subplot(1,2,1)
+            plt.title('CC ' + cases[curr_case])
+            plt.boxplot(all_CC[curr_case], showfliers=False)
+            plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+            plt.subplot(1,2,2)
+            plt.title('MAE ' + cases[curr_case])
+            plt.boxplot(all_MAE[curr_case], showfliers=False)
+            plt.xticks(np.arange(1,len(all_methods)+1), all_methods)'''
+
+            print('\n' + curr_case + '\n')
+
+            data_MAE = np.zeros([len(all_MAE[curr_case][0]), len(all_MAE[curr_case])])
+            for i,m in enumerate(all_MAE[curr_case]):
+                data_MAE[:,i] = m
+
+            n_datasets = data_MAE.shape[0]
+
+            data_CC = np.zeros([len(all_CC[curr_case][0]), len(all_CC[curr_case])])
+            for i,m in enumerate(all_CC[curr_case]):
+                data_CC[:,i] = m
+
+            t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], 
+                                       data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+            avranksMAE = list(np.divide(ranks_mae, n_datasets))
+            print('statistic: ' + str(t))
+            print('pvalue: ' + str(p))
+            print(' ')
+
+            t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], 
+                                     data_CC[:,4], data_CC[:,5], data_CC[:,6], data_CC[:,7])
+            avranksCC = list(np.divide(ranks_cc, n_datasets))
+            print('statistic: ' + str(t))
+            print('pvalue: ' + str(p))
+            print(' ')
+
+            cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+            Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+            plt.title('CD Diagram MAE')
+
+            cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+            Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+            plt.title('CD Diagram CC')
+
+        plt.show()
+    
+    elif CASE == 'full':
+        
+        CC_allcases = []
+        MAE_allcases = []
+        for metric in metrics:
+            for method in all_methods:
+                    raw_values = res[res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+                    
+                    if metric == 'CC':
+                        CC_allcases.append(np.array(values))
+                    if metric == 'MAE':
+                        MAE_allcases.append(np.array(values))
+        
+        data_MAE = np.zeros([len(MAE_allcases[0]), len(MAE_allcases)])
+        for i,m in enumerate(MAE_allcases):
+            data_MAE[:,i] = m
+        
+        n_datasets = data_MAE.shape[0]
+
+        '''data_MAE_df = pd.DataFrame(data_MAE, columns=all_methods)
+        print('\nFriedman Test MAE:')
+        print(ss.friedmanchisquare(*data_MAE.T))
+        print(' ')
+        pc = sp.posthoc_nemenyi_friedman(data_MAE_df)
+        cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+        heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+        plt.figure()
+        sp.sign_plot(pc, **heatmap_args)
+        plt.title('Nemenyi Test MAE')'''
+
+        t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+        avranksMAE = list(np.divide(ranks_mae, n_datasets))
+        print('statistic: ' + str(t))
+        print('pvalue: ' + str(p))
+        print(' ')
+
+        data_CC = np.zeros([len(CC_allcases[0]), len(CC_allcases)])
+        for i,m in enumerate(CC_allcases):
+            data_CC[:,i] = m
+        
+        '''data_CC_df = pd.DataFrame(data_CC, columns=all_methods)
+        print('\nFriedman Test MAE:')
+        print(ss.friedmanchisquare(*data_CC.T))
+        print(' ')
+        pc = sp.posthoc_nemenyi_friedman(data_CC_df)
+        cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+        heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+        plt.figure()
+        sp.sign_plot(pc, **heatmap_args)
+        plt.title('Nemenyi Test CC')'''
+
+        t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], data_CC[:,4], data_CC[:,5], data_CC[:,6], data_CC[:,7])
+        avranksCC = list(np.divide(ranks_cc, n_datasets))
+        print('statistic: ' + str(t))
+        print('pvalue: ' + str(p))
+        print(' ')
+
+        '''plt.figure()
+        plt.subplot(1,2,1)
+        plt.title('CC')
+        plt.boxplot(CC_allcases, showfliers=False)
+        plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+        plt.subplot(1,2,2)
+        plt.title('MAE')
+        plt.boxplot(MAE_allcases, showfliers=False)
+        plt.xticks(np.arange(1,len(all_methods)+1), all_methods)'''
+
+        cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+        Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+        plt.title('CD Diagram MAE')
+
+        cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+        Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+        plt.title('CD Diagram CC')
+
+        plt.show()
+
+
+elif DATASET == 'LGI-PPGI':
+
+    cases = ['gym', 'resting', 'rotation', 'talk']
+    all_CC = {'gym':[], 'resting':[], 'rotation':[], 'talk':[]}
+    all_MAE = {'gym':[], 'resting':[], 'rotation':[], 'talk':[]}
+
+    if CASE == 'split':
+
+        for metric in metrics:
+            for method in all_methods:
+                #print(method)
+                for curr_case in cases:
+
+                    curr_res = res[res['videoName'].str.split('/').str[6].str.split('_').str[1] == curr_case]
+                    raw_values = curr_res[curr_res['method'] == method][metric]
+
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+
+                    if metric == 'CC':
+                        all_CC[curr_case].append(np.array(values))
+                    if metric == 'MAE':
+                        all_MAE[curr_case].append(np.array(values))
+        
+        for curr_case in cases:
+            
+            plt.figure()
+
+            plt.subplot(1,2,1)
+            plt.title('CC ' + curr_case)
+            plt.boxplot(all_CC[curr_case], showfliers=False)
+            plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+            plt.subplot(1,2,2)
+            plt.title('MAE ' + curr_case)
+            plt.boxplot(all_MAE[curr_case], showfliers=False)
+            plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+            print('\n' + curr_case + '\n')
+
+            data_MAE = np.zeros([len(all_MAE[curr_case][0]), len(all_MAE[curr_case])])
+            for i,m in enumerate(all_MAE[curr_case]):
+                data_MAE[:,i] = m
+
+            n_datasets = data_MAE.shape[0]
+
+            data_CC = np.zeros([len(all_CC[curr_case][0]), len(all_CC[curr_case])])
+            for i,m in enumerate(all_CC[curr_case]):
+                data_CC[:,i] = m
+
+            t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+            avranksMAE = list(np.divide(ranks_mae, n_datasets))
+            print('statistic: ' + str(t))
+            print('pvalue: ' + str(p))
+            print(' ')
+
+            t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], data_CC[:,4], data_CC[:,5], data_CC[:,6], data_CC[:,7])
+            avranksCC = list(np.divide(ranks_cc, n_datasets))
+            print('statistic: ' + str(t))
+            print('pvalue: ' + str(p))
+            print(' ')
+
+            cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+            Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+            plt.title('CD Diagram MAE')
+
+            cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+            Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+            plt.title('CD Diagram CC')
+
+        plt.show()
+
+    elif CASE == 'full':
+        
+        CC_allcases = []
+        MAE_allcases = []
+        for metric in metrics:
+            for method in all_methods:
+                    raw_values = res[res['method'] == method][metric]
+                    
+                    values = []
+                    for v in raw_values:
+                        if metric == 'CC':
+                            values.append(v[np.argmax(v)])
+                        else:
+                            values.append(v[np.argmin(v)])
+                    
+                    if metric == 'CC':
+                        CC_allcases.append(np.array(values))
+                    if metric == 'MAE':
+                        MAE_allcases.append(np.array(values))
+        
+        data_MAE = np.zeros([len(MAE_allcases[0]), len(MAE_allcases)])
+        for i,m in enumerate(MAE_allcases):
+            data_MAE[:,i] = m
+
+        n_datasets = data_MAE.shape[0]
+        
+        data_MAE_df = pd.DataFrame(data_MAE, columns=all_methods)
+        print('\nFriedman Test MAE:')
+        print(ss.friedmanchisquare(*data_MAE.T))
+        print(' ')
+        pc = sp.posthoc_nemenyi_friedman(data_MAE_df)
+        cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+        heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+        plt.figure()
+        sp.sign_plot(pc, **heatmap_args)
+        plt.title('Nemenyi Test MAE')
+
+        t,p,ranks_mae,piv_mae = ft(data_MAE[:,0], data_MAE[:,1], data_MAE[:,2], data_MAE[:,3], data_MAE[:,4], data_MAE[:,5], data_MAE[:,6], data_MAE[:,7])
+        avranksMAE = list(np.divide(ranks_mae, n_datasets))
+        print('statistic: ' + str(t))
+        print('pvalue: ' + str(p))
+        print(' ')
+
+        data_CC = np.zeros([len(CC_allcases[0]), len(CC_allcases)])
+        for i,m in enumerate(CC_allcases):
+            data_CC[:,i] = m
+        
+        data_CC_df = pd.DataFrame(data_CC, columns=all_methods)
+        print('\nFriedman Test CC:')
+        print(ss.friedmanchisquare(*data_CC.T))
+        print(' ')
+        pc = sp.posthoc_nemenyi_friedman(data_CC_df)
+        cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+        heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.80, 0.35, 0.04, 0.3]}
+        plt.figure()
+        sp.sign_plot(pc, **heatmap_args)
+        plt.title('Nemenyi Test CC')
+
+        t,p,ranks_cc,piv_cc = ft(data_CC[:,0], data_CC[:,1], data_CC[:,2], data_CC[:,3], data_CC[:,4], data_CC[:,5], data_CC[:,6], data_CC[:,7])
+        avranksCC = list(np.divide(ranks_cc, n_datasets))
+        print('statistic: ' + str(t))
+        print('pvalue: ' + str(p))
+        print(' ')
+
+        plt.figure()
+        plt.subplot(1,2,1)
+        plt.title('CC')
+        plt.boxplot(CC_allcases, showfliers=False)
+        plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+        plt.subplot(1,2,2)
+        plt.title('MAE')
+        plt.boxplot(MAE_allcases, showfliers=False)
+        plt.xticks(np.arange(1,len(all_methods)+1), all_methods)
+
+        cd = Orange.evaluation.compute_CD(avranksMAE, n_datasets, alpha=alpha) #tested on 30 datasets
+        Orange.evaluation.graph_ranks(avranksMAE, all_methods, cd=cd, width=6, textspace=1.5, reverse=True)
+        plt.title('CD Diagram MAE')
+
+        cd = Orange.evaluation.compute_CD(avranksCC, n_datasets, alpha=alpha) #tested on 30 datasets
+        Orange.evaluation.graph_ranks(avranksCC, all_methods, cd=cd, width=6, textspace=1.5)
+        plt.title('CD Diagram CC')
+
+        plt.show()

ssr.py

@@ -0,0 +1,164 @@
+import numpy as np
+from .utils.SkinColorFilter import SkinColorFilter
+from .base import VHRMethod
+
+class SSR(VHRMethod):
+    methodName = 'SSR'
+
+    def __init__(self, **kwargs):
+        super(SSR, self).__init__(**kwargs)
+        
+    def apply(self, X):
+
+        K = len(self.video.faceSignal)
+        l = self.video.frameRate
+
+        P = np.zeros(K)  # 1 | dim: K
+        # store the eigenvalues Λ and the eigenvectors U at each frame
+        L = np.zeros((3, K), dtype='float64')  # dim: 3xK
+        U = np.zeros((3, 3, K), dtype='float64')  # dim: 3x3xK
+
+        for k in range(K):
+            n_roi = len(self.video.faceSignal[k])
+            VV = []
+
+            for r in range(n_roi):
+                V = self.video.faceSignal[k][r].astype(np.float64)
+                idx = V!=0
+                idx2 = np.logical_and(np.logical_and(idx[:,:,0], idx[:,:,1]), idx[:,:,2])
+                V_skin_only = V[idx2]
+                VV.append(V_skin_only)
+            
+            VV = np.vstack(VV)
+
+            C = self.__build_correlation_matrix(VV)  #dim: 3x3
+
+            # get: eigenvalues Λ, eigenvectors U
+            L[:,k], U[:,:,k] = self.__eigs(C)  # dim Λ: 3 | dim U: 3x3
+
+            # build p and add it to the pulse signal P
+            if k >= l:  # 5
+                tau = k - l  # 5
+                p = self.__build_p(tau, k, l, U, L)  # 6, 7, 8, 9, 10, 11 | dim: l
+                P[tau:k] += p  # 11
+
+            if np.isnan(np.sum(P)):
+                print('NAN')
+                print(self.video.faceSignal[k])
+                
+        bvp = P
+  
+        return bvp
+
+    def __build_p(self, τ, k, l, U, Λ):
+        """
+        builds P
+        Parameters
+        ----------
+        k: int
+            The frame index
+        l: int
+            The temporal stride to use
+        U: numpy.ndarray
+            The eigenvectors of the c matrix (for all frames up to counter).
+        Λ: numpy.ndarray
+            The eigenvalues of the c matrix (for all frames up to counter).
+        Returns
+        -------
+        p: numpy.ndarray
+            The p signal to add to the pulse.
+        """
+        # SR'
+        SR = np.zeros((3, l), 'float64')  # dim: 3xl
+        z = 0
+
+        for t in range(τ, k, 1):  # 6, 7
+            a = Λ[0, t]
+            b = Λ[1, τ]
+            c = Λ[2, τ]
+            d = U[:, 0, t].T
+            e = U[:, 1, τ]
+            f = U[:, 2, τ]
+            g = U[:, 1, τ].T
+            h = U[:, 2, τ].T
+            x1 = a / b
+            x2 = a / c
+            x3 = np.outer(e, g)
+            x4 = np.dot(d, x3)
+            x5 = np.outer(f, h)
+            x6 = np.dot(d, x5)
+            x7 = np.sqrt(x1)
+            x8 = np.sqrt(x2)
+            x9 = x7 * x4
+            x10 = x8 * x6
+            x11 = x9 + x10
+            SR[:, z] = x11  # 8 | dim: 3
+            z += 1
+
+        # build p and add it to the final pulse signal
+        s0 = SR[0, :]  # dim: l
+        s1 = SR[1, :]  # dim: l
+        p = s0 - ((np.std(s0) / np.std(s1)) * s1)  # 10 | dim: l
+        p = p - np.mean(p)  # 11
+        return p  # dim: l
+
+    def __get_skin_pixels(self, skin_filter, face, do_skininit):
+        """
+        get eigenvalues and eigenvectors, sort them.
+        Parameters
+        ----------
+        C: numpy.ndarray
+            The RGB values of skin-colored pixels.
+        Returns
+        -------
+        Λ: numpy.ndarray
+            The eigenvalues of the correlation matrix
+        U: numpy.ndarray
+            The (sorted) eigenvectors of the correlation matrix
+        """
+        ROI = face
+
+        if do_skininit:
+            skin_filter.estimate_gaussian_parameters(ROI)
+
+        skin_mask = skin_filter.get_skin_mask(ROI)  # dim: wxh
+
+        V = ROI[skin_mask]  # dim: (w×h)x3
+        V = V.astype('float64') / 255.0
+
+        return V
+
+
+    def __build_correlation_matrix(self, V):
+        # V dim: (W×H)x3
+        #V = np.unique(V, axis=0)
+        V_T = V.T  # dim: 3x(W×H)
+        N = V.shape[0]
+        # build the correlation matrix
+        C = np.dot(V_T, V)  # dim: 3x3
+        C = C / N
+
+        return C
+
+    def __eigs(self, C):
+        """
+        get eigenvalues and eigenvectors, sort them.
+        Parameters
+        ----------
+        C: numpy.ndarray
+            The RGB values of skin-colored pixels.
+        Returns
+        -------
+        Λ: numpy.ndarray
+            The eigenvalues of the correlation matrix
+        U: numpy.ndarray
+            The (sorted) eigenvectors of the correlation matrix
+        """
+        # get eigenvectors and sort them according to eigenvalues (largest first)
+        L, U = np.linalg.eig(C)  # dim Λ: 3 | dim U: 3x3
+        idx = L.argsort()  # dim: 3x1
+        idx = idx[::-1]  # dim: 1x3
+        L_ = L[idx]  # dim: 3
+        U_ = U[:, idx]  # dim: 3x3
+
+        return L_, U_

stats.py

@@ -0,0 +1,344 @@
+import pandas as pd
+import numpy as np
+import os
+import re 
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import scipy.stats as ss
+import scikit_posthocs as sp
+from .stattests import friedman_aligned_ranks_test as ft
+import Orange
+
+class StatAnalysis():
+    """ Statistics analysis for multiple datasets and multiple VHR methods"""
+    
+    def __init__(self, filepath='default'):
+        
+        if os.path.isdir(filepath):  
+            self.multidataset = True
+            self.path = filepath + "/"
+            self.datasetsList = os.listdir(filepath)
+        elif os.path.isfile(filepath):  
+            self.multidataset = False
+            self.datasetsList = [filepath]
+            self.path = ""
+        else:  
+            raise("Error: filepath is wrong!")
+        
+        # -- get common methods
+        self.__getMethods()
+        self.metricSort = {'MAE':'min','RMSE':'min','CC':'max','PCC':'max'}
+        self.scale = {'MAE':'log','RMSE':'log','CC':'linear','PCC':'linear'}
+
+    def FriedmanTest(self, methods=None, metric='MAE'):
+        
+        # -- Method(s) 
+        if methods == None:
+            methods = self.methods
+        else:
+            if set(methods) <= set(self.methods):
+                raise("Some method is wrong!")
+            else:
+                self.methods = methods
+           
+        # -- set metric
+        self.metric = metric
+        self.mag = self.metricSort[metric]
+        
+        # -- get data from dataset(s)
+        #    return Y = mat(n-datasets,k-methods)   
+        if self.multidataset:
+            Y = self.__getData()
+        else:
+            Y = self.__getDataMono()
+        self.ndataset = Y.shape[0]
+        
+        # -- Friedman test
+        t,p,ranks,piv = ft(Y)
+        self.avranks = list(np.divide(ranks, self.ndataset))
+        
+        return t,p,ranks,piv,self.ndataset
+    
+    def SignificancePlot(self, methods=None, metric='MAE'):
+
+        # -- Method(s) 
+        if methods == None:
+            methods = self.methods
+        else:
+            if set(methods) <= set(self.methods):
+                raise("Some method is wrong!")
+            else:
+                self.methods = methods
+           
+        # -- set metric
+        self.metric = metric
+        self.mag = self.metricSort[metric]
+        
+        # -- get data from dataset(s)
+        if self.multidataset:
+            Y = self.__getData()
+        else:
+            Y = self.__getDataMono()
+        
+        # -- Significance plot, a heatmap of p values
+        methodNames = [x.upper() for x in self.methods]
+        Ypd = pd.DataFrame(Y, columns=methodNames)
+        ph = sp.posthoc_nemenyi_friedman(Ypd)
+        cmap = ['1', '#fb6a4a',  '#08306b',  '#4292c6', '#c6dbef']
+        heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', 
+                        'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.85, 0.35, 0.04, 0.3]}
+
+        plt.figure(figsize=(5,4))
+        sp.sign_plot(ph, cbar=True, **heatmap_args)
+        plt.title('p-vals')
+        
+        fname = 'SP_' + self.metric + '.pdf'
+        plt.savefig(fname)
+        plt.show()
+        
+    def computeCD(self, avranks=None, numDatasets=None, alpha='0.05', display=True):
+        """
+        Returns critical difference for Nemenyi or Bonferroni-Dunn test according 
+        to given alpha (either alpha=”0.05” or alpha=”0.1”) for average ranks and 
+        number of tested datasets N. Test can be either “nemenyi” for for Nemenyi 
+        two tailed test or “bonferroni-dunn” for Bonferroni-Dunn test.
+        See Orange package docs.
+        """
+        if not numDatasets:
+            numDatasets = self.ndataset
+        if not avranks:
+            avranks = self.avranks
+        
+        cd = Orange.evaluation.compute_CD(avranks, numDatasets, alpha=alpha) #tested on 30 datasets
+        
+        if self.mag == 'min':
+            reverse = True
+        else:
+            reverse = False
+        
+        methodNames = [x.upper() for x in self.methods]
+        if display:
+            Orange.evaluation.graph_ranks(avranks, methodNames, cd=cd, width=6, textspace=1.5, reverse=reverse)
+            name = 'CD Diagram (metric: ' + self.metric +')'
+            plt.title(name)  
+            fname = 'CD_' + self.metric + '.pdf'
+            plt.savefig(fname)
+            
+            plt.show()
+        return cd
+
+    def displayBoxPlot(self, methods=None, metric='MAE', scale=None, title=True):
+  
+        # -- Method(s) 
+        if methods == None:
+            methods = self.methods
+        else:
+            if set(methods) <= set(self.methods):
+                raise("Some method is wrong!")
+            else:
+                self.methods = methods
+           
+        # -- set metric
+        self.metric = metric
+        self.mag = self.metricSort[metric]
+        if scale == None:
+            scale = self.scale[metric]
+        
+        # -- get data from dataset(s)
+        if self.multidataset:
+            Y = self.__getData()
+        else:
+            Y = self.__getDataMono()
+       
+        # -- display box plot
+        self.boxPlot(methods, metric, Y, scale=scale, title=title)
+        
+    def boxPlot(self, methods, metric, Y, scale, title):
+        
+        #  Y = mat(n-datasets,k-methods)   
+        
+        k = len(methods)
+        
+        if not (k == Y.shape[1]):
+            raise("error!")
+
+        offset = 50
+        fig = go.Figure()
+
+        methodNames = [x.upper() for x in self.methods]
+        for i in range(k):
+            yd = Y[:,i]
+            name = methodNames[i]
+            # -- set color for box
+            if metric == 'MAE' or  metric == 'RMSE':
+                med = np.median(yd)
+                col = str(min(200,5*int(med)+offset))
+            if metric == 'CC' or metric == 'PCC':
+                med = 1-np.abs(np.median(yd))
+                col = str(int(200*med)+offset)
+
+            # -- add box 
+            fig.add_trace(go.Box(
+                y=yd,
+                name=name,
+                boxpoints='all',
+                jitter=.7,
+                #whiskerwidth=0.2,
+                fillcolor="rgba("+col+","+col+","+col+",0.5)",
+                line_color="rgba(0,0,255,0.5)",
+                marker_size=2,
+                line_width=2)
+            )
+
+        gwidth = np.max(Y)/10
+        
+        if title:
+            tit = "Metric: " + metric
+            top = 40
+        else:
+            tit=''
+            top = 10
+        
+        fig.update_layout(
+            title=tit,
+            yaxis_type=scale,
+            xaxis_type="category",
+            yaxis=dict(
+                autorange=True,
+                showgrid=True,
+                zeroline=True,
+                #dtick=gwidth,
+                gridcolor='rgb(255,255,255)',
+                gridwidth=.1,
+                zerolinewidth=2,
+                titlefont=dict(size=30)
+            ),
+            font=dict(
+                family="monospace",
+                size=16,
+                color='rgb(20,20,20)'
+            ),
+            margin=dict(
+                l=20,
+                r=10,
+                b=20,
+                t=top,
+            ),
+            paper_bgcolor='rgb(250, 250, 250)',
+            plot_bgcolor='rgb(243, 243, 243)',
+            showlegend=False
+        )
+
+        fig.show()
+        
+    def saveStatsData(self, methods=None, metric='MAE', outfilename='statsData.csv'):
+        Y = self.getStatsData(methods=methods, metric=metric, printTable=False)
+        np.savetxt(outfilename, Y)
+        
+    def getStatsData(self, methods=None, metric='MAE', printTable=True):
+         # -- Method(s) 
+        if methods == None:
+            methods = self.methods
+        else:
+            if set(methods) <= set(self.methods):
+                raise("Some method is wrong!")
+            else:
+                self.methods = methods
+           
+        # -- set metric
+        self.metric = metric
+        self.mag = self.metricSort[metric]
+        
+          # -- get data from dataset(s)
+        #    return Y = mat(n-datasets,k-methods)   
+        if self.multidataset:
+            Y = self.__getData()
+        else:
+            Y = self.__getDataMono()
+           
+        # -- add median and IQR
+        I = ss.iqr(Y,axis=0)
+        M = np.median(Y,axis=0)
+        Y = np.vstack((Y,M))
+        Y = np.vstack((Y,I))
+        
+        if printTable:
+            methodNames = [x.upper() for x in self.methods]
+            dataseNames = self.datasetNames
+            dataseNames.append('Median')
+            dataseNames.append('IQR')
+            df = pd.DataFrame(Y, columns=methodNames, index=dataseNames)
+            display(df)
+        
+        return Y
+
+    def __getDataMono(self):
+        mag = self.mag
+        metric = self.metric
+        methods = self.methods
+        
+        frame = self.dataFrame[0]
+        # -- loop on methods
+        Y = []
+        for method in methods:
+            vals = frame[frame['method'] == method][metric]
+            if mag == 'min':
+                data = [v[np.argmin(v)] for v in vals]
+            else:
+                data = [v[np.argmax(v)] for v in vals]
+            Y.append(data)
+            
+        return np.array(Y).T
+
+    def __getData(self):
+        
+        mag = self.mag
+        metric = self.metric
+        methods = self.methods
+        
+        # -- loop on datasets
+        Y = []
+        for frame in self.dataFrame:
+           
+            # -- loop on methods
+            y = []
+            for method in methods:
+                vals = frame[frame['method'] == method][metric]
+                if mag == 'min':
+                    data = [v[np.argmin(v)] for v in vals]
+                else:
+                    data = [v[np.argmax(v)] for v in vals]
+
+                y.append(data)
+            
+            y = np.array(y)
+            Y.append(np.mean(y,axis=1)) 
+        return np.array(Y)
+    
+    def __getMethods(self):
+        
+        mets = []
+        dataFrame = []
+        N = len(self.datasetsList)
+        
+        # -- load dataframes
+        self.datasetNames = []
+        for file in self.datasetsList:
+            filename = self.path + file
+            self.datasetNames.append(file)
+            data = pd.read_hdf(filename)
+            mets.append(set(list(data['method'])))
+            dataFrame.append(data)
+
+        # -- method names intersection among datasets
+        methods = set(mets[0])
+        if N > 1:
+            for m in range(1,N-1):
+                methods.intersection(mets[m])
+
+        methods = list(methods)
+        methods.sort()
+        self.methods = methods
+        self.dataFrame = dataFrame
+
+            

stattests.py

@@ -0,0 +1,614 @@
+import numpy as np
+import scipy as sp
+import scipy.stats as st
+import itertools as it
+
+def binomial_sign_test(*args):
+    """
+        Performs a binomial sign test for two dependent samples.
+        Tests the hypothesis that the two dependent samples represent two different populations.
+        
+        Parameters
+        ----------
+        sample1, sample2: array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        B-value : float
+            The computed B-value of the test.
+        p-value : float
+            The associated p-value from the B-distribution.
+            
+        References
+        ----------
+        D.J. Sheskin, Handbook of parametric and nonparametric statistical procedures. 
+        crc Press, 2003, Test 19: The Binomial Sign Test for Two Dependent Samples
+    """
+    k = len(args)
+    if k != 2: raise ValueError('The test needs two samples')
+    n = len(args[0])
+    
+    d_plus = 0
+    d_minus = 0
+    for i in range(n):
+        # Zero differences are eliminated
+        if args[0][i] < args[1][i]: 
+            d_plus = d_plus+1
+        elif args[0][i] > args[1][i]:
+            d_minus = d_minus+1
+    
+    x = max(d_plus, d_minus)
+    n = d_plus + d_minus
+    
+    p_value = 2*(1 - st.binom.cdf(x, n, 0.5)) # Two-tailed of the smallest p-value
+    
+    return x, p_value
+
+def friedman_aligned_ranks_test(S):
+    """
+        Performs a Friedman aligned ranks ranking test.
+        Tests the hypothesis that in a set of k dependent samples groups (where k >= 2) 
+        at least two of the groups represent populations with different median values.
+        The difference with a friedman test is that it uses the median of each group to 
+        construct the ranking, which is useful when the number of samples is low.
+        
+        Parameters
+        ----------
+        S = [sample1, sample2, ... sample_k] : matrix(n,k)
+            The sample measurements (matrix columns) for each group.
+            
+        Returns
+        -------
+        Chi2-value : float
+            The computed Chi2-value of the test.
+        p-value : float
+            The associated p-value from the Chi2-distribution.
+        rankings : array_like
+            The ranking for each group.
+        pivots : array_like
+            The pivotal quantities for each group.
+            
+        References
+        ----------
+         J.L. Hodges, E.L. Lehmann, Ranks methods for combination of independent experiments 
+         in analysis of variance, Annals of Mathematical Statistics 33 (1962) 482–497.
+    """
+    
+    # modified from the original
+    n,k = S.shape # n samples, k groups
+    
+    aligned_observations = []
+    for i in range(n):
+        loc = sp.mean(S[i])
+        aligned_observations.extend(S[i]-loc)
+        
+    aligned_observations_sort = sorted(aligned_observations)
+    
+    aligned_ranks = []
+    for i in range(n):
+        row = []
+        for j in range(k):
+            v = aligned_observations[i*k+j]
+            row.append(aligned_observations_sort.index(v) + 1 + (aligned_observations_sort.count(v)-1)/2.)
+        aligned_ranks.append(row)
+
+    rankings_avg = [sp.mean([case[j] for case in aligned_ranks]) for j in range(k)]
+    rankings_cmp = [r/sp.sqrt(k*(n*k+1)/6.) for r in rankings_avg]
+
+    r_i = [np.sum(case) for case in aligned_ranks]
+    r_j = [np.sum([case[j] for case in aligned_ranks]) for j in range(k)]
+    T = (k-1) * (sp.sum(v**2 for v in r_j) - (k*n**2/4.) * (k*n+1)**2) / float(((k*n*(k*n+1)*(2*k*n+1))/6.) - (1./float(k))*sp.sum(v**2 for v in r_i))
+
+    p_value = 1 - st.chi2.cdf(T, k-1)
+
+    return T, p_value, rankings_avg, rankings_cmp
+
+def quade_test(*args):
+    """
+        Performs a Quade ranking test.
+        Tests the hypothesis that in a set of k dependent samples groups (where k >= 2) at least two of the groups represent populations with different median values.
+        The difference with a friedman test is that it uses the median for each sample to wiehgt the ranking.
+        
+        Parameters
+        ----------
+        sample1, sample2, ... : array_like
+            The sample measurements for each group.
+            
+        Returns
+        -------
+        F-value : float
+            The computed F-value of the test.
+        p-value : float
+            The associated p-value from the F-distribution.
+        rankings : array_like
+            The ranking for each group.
+        pivots : array_like
+            The pivotal quantities for each group.
+            
+        References
+        ----------
+        D. Quade, Using weighted rankings in the analysis of complete blocks with additive block effects, Journal of the American Statistical Association 74 (1979) 680–683.
+    """
+    k = len(args)
+    if k < 2: raise ValueError('Less than 2 levels')
+    n = len(args[0])
+    if len(set([len(v) for v in args])) != 1: raise ValueError('Unequal number of samples')
+
+    rankings = []
+    ranges = []
+    for i in range(n):
+        row = [col[i] for col in args]
+        ranges.append(max(row) - min(row))
+        row_sort = sorted(row)
+        rankings.append([row_sort.index(v) + 1 + (row_sort.count(v)-1)/2. for v in row])
+   
+    ranges_sort = sorted(ranges)
+    ranking_cases = [ranges_sort.index(v) + 1 + (ranges_sort.count(v)-1)/2. for v in ranges]
+
+    S = []
+    W = []
+    for i in range(n):
+        S.append([ranking_cases[i] * (r - (k + 1)/2.) for r in rankings[i]])
+        W.append([ranking_cases[i] * r for r in rankings[i]])
+
+    Sj = [np.sum(row[j] for row in S) for j in range(k)]
+    Wj = [np.sum(row[j] for row in W) for j in range(k)]
+    
+    rankings_avg = [w / (n*(n+1)/2.) for w in Wj]
+    rankings_cmp = [r/sp.sqrt(k*(k+1)*(2*n+1)*(k-1)/(18.*n*(n+1))) for r in rankings_avg]
+
+    A = sp.sum(S[i][j]**2 for i in range(n) for j in range(k))
+    B = sp.sum(s**2 for s in Sj)/float(n)
+    F = (n-1)*B/(A-B)
+
+    p_value = 1 - st.f.cdf(F, k-1, (k-1)*(n-1))
+
+    return F, p_value, rankings_avg, rankings_cmp
+
+def bonferroni_dunn_test(ranks, control=None):
+    """
+        Performs a Bonferroni-Dunn post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method (one vs all), default None (all vs all) 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. Dunn, Multiple comparisons among means, Journal of the American Statistical Association 56 (1961) 52–64.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min((k-1)*p_value,1) for p_value in p_values]
+    
+    return comparisons, z_values, p_values, adj_p_values
+      
+def holm_test(ranks, control=None):
+    """
+        Performs a Holm post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method (one vs all), default None (all vs all) 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. S. Holm, A simple sequentially rejective multiple test procedure, Scandinavian 
+        Journal of Statistics 6 (1979) 65–70.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max((k-(j+1))*p_values[j] for j in range(i+1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+      
+def hochberg_test(ranks, control=None):
+    """
+        Performs a Hochberg post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Y. Hochberg, A sharper Bonferroni procedure for multiple tests of significance, 
+        Biometrika 75 (1988) 800–803.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max((k-j)*p_values[j-1] for j in range(k-1, i, -1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def li_test(ranks, control=None):
+    """
+        Performs a Li post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        J. Li, A two-step rejection procedure for testing multiple hypotheses, Journal of 
+        Statistical Planning and Inference 138 (2008) 1521–1527.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [p_values[i]/(p_values[i]+1-p_values[-1]) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def finner_test(ranks, control=None):
+    """
+        Performs a Finner post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of the control method is different to each of the other methods.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+        control : string optional
+            The name of the control method,  default the group with minimum ranking
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        H. Finner, On a monotonicity problem in step-down multiple test procedures, Journal 
+        of the American Statistical Association 88 (1993) 920–923.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    if not control :
+        control_i = values.index(min(values))
+    else:
+        control_i = keys.index(control)
+
+    comparisons = [keys[control_i] + " vs " + keys[i] for i in range(k) if i != control_i]
+    z_values = [abs(values[control_i] - values[i]) for i in range(k) if i != control_i]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max(1-(1-p_values[j])**((k-1)/float(j+1)) for j in range(i+1)), 1) for i in range(k-1)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def nemenyi_multitest(ranks):
+    """
+        Performs a Nemenyi post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Bonferroni-Dunn: O.J. Dunn, Multiple comparisons among means, Journal of the American 
+        Statistical Association 56 (1961) 52–64.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(m*p_value,1) for p_value in p_values]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def holm_multitest(ranks):
+    """
+        Performs a Holm post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        O.J. S. Holm, A simple sequentially rejective multiple test procedure, Scandinavian Journal 
+        of Statistics 6 (1979) 65–70.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(max((m-j)*p_values[j] for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def hochberg_multitest(ranks):
+    """
+        Performs a Hochberg post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        Y. Hochberg, A sharper Bonferroni procedure for multiple tests of significance, Biometrika 75 (1988) 800–803.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [max((m+1-j)*p_values[j-1] for j in range(m, i, -1))for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+    
+def finner_multitest(ranks):
+    """
+        Performs a Finner post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        H. Finner, On a monotonicity problem in step-down multiple test procedures, Journal of the 
+        American Statistical Association 88 (1993) 920–923.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    m = int(k*(k-1)/2.)
+    adj_p_values = [min(max(1-(1-p_values[j])**(m/float(j+1)) for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values
+
+def _S(k):
+    """
+        Helper function for the Shaffer test.
+        It obtains the number of independent test hypotheses when using an All vs 
+        All strategy using the number of groups to be compared.
+    """
+    if k == 0 or k == 1:
+        return {0}
+    else:
+        result = set()
+        for j in reversed(range(1, k+1)):
+            tmp = S(k - j)
+            for s in tmp:
+                result = result.union({sp.special.binom(j, 2) + s})
+        return list(result)
+
+def shaffer_multitest(ranks):
+    """
+        Performs a Shaffer post-hoc test using the pivot quantities obtained by a ranking test.
+        Tests the hypothesis that the ranking of each pair of groups are different.
+        
+        Parameters
+        ----------
+        pivots : dictionary_like
+            A dictionary with format 'groupname':'pivotal quantity' 
+            
+        Returns
+        ----------
+        Comparions : array-like
+            Strings identifier of each comparison with format 'group_i vs group_j'
+        Z-values : array-like
+            The computed Z-value statistic for each comparison.
+        p-values : array-like
+            The associated p-value from the Z-distribution wich depends on the index of the comparison
+        Adjusted p-values : array-like
+            The associated adjusted p-values wich can be compared with a significance level
+            
+        References
+        ----------
+        J. Li, A two-step rejection procedure for testing multiple hypotheses, Journal of Statistical 
+        Planning and Inference 138 (2008) 1521–1527.
+    """
+    k = len(ranks)
+    values = ranks.values()
+    keys = ranks.keys()
+    versus = list(it.combinations(range(k), 2))
+    
+    m = int(k*(k-1)/2.)
+    A = _S(int((1 + sp.sqrt(1+4*m*2))/2))
+    t = [max([a for a in A if a <= m-i]) for i in range(m)]
+
+    comparisons = [keys[vs[0]] + " vs " + keys[vs[1]] for vs in versus]
+    z_values = [abs(values[vs[0]] - values[vs[1]]) for vs in versus]
+    p_values = [2*(1-st.norm.cdf(abs(z))) for z in z_values]
+    # Sort values by p_value so that p_0 < p_1
+    p_values, z_values, comparisons = map(list, zip(*sorted(zip(p_values, z_values, comparisons), key=lambda t: t[0])))
+    adj_p_values = [min(max(t[j]*p_values[j] for j in range(i+1)), 1) for i in range(m)]
+    
+    return comparisons, z_values, p_values, adj_p_values

testsuite.py

@@ -0,0 +1,203 @@
+import configparser
+import ast
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from ..datasets.dataset import datasetFactory
+from ..methods.base import methodFactory
+from ..signals.video import Video
+from ..utils.errors import getErrors, printErrors, displayErrors
+
+class TestSuite():
+    """ Test suite for a given video dataset and multiple VHR methods"""
+    
+    def __init__(self, configFilename='default'):
+        if configFilename == 'default':
+            configFilename = '../pyVHR/analysis/default_test.cfg'
+        self.parse_cfg(configFilename)
+        
+    def start(self, saveResults=True, outFilename=None, verb=0):
+        """ Runs the tests as specified in the loaded config file.
+            
+            verbose degree:
+               0 - not verbose
+               1 - show the main steps
+               2 - display graphic 
+               3 - display spectra  
+               4 - display errors
+               (use also combinations, e.g. verb=21, verb=321)
+        """     
+
+        # -- verbose prints
+        if '1' in str(verb):
+            self.__verbose('a')
+            
+        # -- dataset & cfg params
+        #dataset = datasetFactory(self.videodict['dataset'])
+        dataset = datasetFactory(self.videodict['dataset'], videodataDIR=self.videodict['videodataDIR'], BVPdataDIR=self.videodict['BVPdataDIR'])
+        
+        # -- catch data (object)
+        res = TestResult()
+        
+        # -- loop on methods 
+        for m in self.methods:
+            
+            # -- loop on videos 
+            if self.videoIdx == 'all':
+                self.videoIdx = np.arange(0,dataset.numVideos)
+            for v in self.videoIdx:
+                
+                # -- verbose prints
+                if '1' in str(verb):
+                    print("\n**** Using Method: %s on videoID: %d" % (m,v))
+                
+                # -- catch data
+                res.newDataSerie()
+                res.addData('method', m)
+                res.addData('dataset', dataset.name)
+                res.addData('videoIdx', v)
+                
+                # -- video object
+                videoFilename = dataset.getVideoFilename(v)
+                video = Video(videoFilename, verb)
+                video.getCroppedFaces(detector=self.videodict['detector'],
+                                      extractor=self.videodict['extractor'])
+                etime = float(self.videodict['endTime'])
+                if etime < 0:
+                    self.videodict['endTime'] = str(video.duration-etime)
+                # -- catch data
+                res.addData('videoFilename', videoFilename)
+                
+                # -- ground-truth signal
+                fname = dataset.getSigFilename(v)
+                sigGT = dataset.readSigfile(fname)
+                winSizeGT = int(self.methodsdict[m]['winSizeGT'])
+                bpmGT, timesGT = sigGT.getBPM(winSizeGT)
+                # -- catch data
+                res.addData('sigFilename', fname)
+                res.addData('bpmGT', sigGT.bpm)
+                res.addData('timeGT', sigGT.times)         
+
+                # -- method object
+                # load params of m
+                self.methodsdict[m]['video'] = video
+                self.methodsdict[m]['verb'] = verb
+                # merge video parameters dict in method parameters dict before calling method
+                self.__merge(self.methodsdict[m], self.videodict)
+                method = methodFactory(m, **self.methodsdict[m])
+                bpmES, timesES = method.runOffline(**self.methodsdict[m])
+                # -- catch data
+                res.addData('bpmES', bpmES)
+                res.addData('timeES', timesES) 
+                
+                # -- error metrics
+                RMSE, MAE, MAX, PCC = getErrors(bpmES, bpmGT, timesES, timesGT)
+                # -- catch data
+                res.addData('RMSE', RMSE)
+                res.addData('MAE', MAE) 
+                res.addData('PCC', PCC)
+                res.addData('MAX', MAX)
+                res.addDataSerie()
+                
+                if '1' in str(verb):
+                    printErrors(RMSE, MAE, MAX, PCC)
+                if '4' in str(verb):
+                    displayErrors(bpmES, bpmGT, timesES, timesGT)
+                    
+        # -- save results on a file
+        if saveResults:
+            res.saveResults()
+
+        return res
+    
+    
+    def parse_cfg(self, configFilename):
+        """ parses the given config file for experiments. """
+        
+        self.parser = configparser.ConfigParser(inline_comment_prefixes=('#', ';'))
+        self.parser.optionxform = str
+        if not self.parser.read(configFilename):
+            raise FileNotFoundError(configFilename)
+            
+        # checks 
+        assert not self.parser.has_section('DEFAULT'),"ERROR... DEFAULT section is mandatory!"
+            
+        # load default paramas
+        self.defaultdict = dict(self.parser['DEFAULT'].items())
+        
+        # load video params
+        self.videodict = dict(self.parser['VIDEO'].items())
+        
+        # video idx list extraction
+        if self.videodict['videoIdx'] == 'all':
+            self.videoIdx = 'all'
+        else:
+            svid = ast.literal_eval(self.videodict['videoIdx'])
+            self.videoIdx = [int(v) for v in svid]
+
+        # load parameters for each methods
+        self.methodsdict = {}
+        self.methods = ast.literal_eval(self.defaultdict['methods'])
+        for x in self.methods:
+            self.methodsdict[x] = dict(self.parser[x].items())
+        
+    def __merge(self, dict1, dict2):
+        for key in dict2:
+            if key not in dict1:
+                dict1[key]= dict2[key]
+                
+    def __verbose(self, verb):
+        if verb == 'a':
+            print("** Run the test with the following config:")
+            print("      dataset: " + self.videodict['dataset'].upper())
+            print("      methods: " + str(self.methods))
+
+            
+class TestResult():
+    """ Manage the results of a test for a given video dataset and multiple VHR methods"""
+    
+    def __init__(self, filename=None):
+
+        if filename == None:
+            self.dataFrame = pd.DataFrame()
+        else:
+            self.dataFrame = pd.read_hdf(filename)
+        self.dict = None
+        
+    def addDataSerie(self):
+        # -- store serie
+        if self.dict != None:
+            self.dataFrame = self.dataFrame.append(self.dict, ignore_index=True)
+            
+    def newDataSerie(self):
+        # -- new dict
+        D = {}
+        D['method'] = ''
+        D['dataset'] = ''
+        D['videoIdx'] = ''        # video filename
+        D['sigFilename'] = ''     # GT signal filename
+        D['videoFilename'] = ''   # GT signal filename
+        D['EVM'] = False          # True if used, False otherwise
+        D['mask'] = ''            # mask used
+        D['RMSE'] = ''
+        D['MAE'] = ''
+        D['PCC'] = ''
+        D['MAX'] = ''
+        D['telapse'] = ''
+        D['bpmGT'] = ''          # GT bpm
+        D['bpmES'] = ''
+        D['timeGT'] = ''            # GT bpm
+        D['timeES'] = ''    
+        self.dict = D
+    
+    def addData(self, key, value):
+        self.dict[key] = value
+                         
+    def saveResults(self, outFilename=None):
+        if outFilename == None:
+            outFilename = "testResults.h5"
+        else:
+            self.outFilename = outFilename
+        
+        # -- save data
+        self.dataFrame.to_hdf(outFilename, key='df', mode='w')

ubfc1.py

@@ -0,0 +1,52 @@
+import csv
+import numpy as np
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class UBFC1(Dataset):
+    """
+    UBFC dataset structure:
+    -----------------
+        datasetDIR/
+        |   |-- SubjDIR1/
+        |       |-- vid.avi
+        |...
+        |   |-- SubjDIRM/
+        |       |-- vid.avi
+    """
+    name = 'UBFC1'
+    signalGT = 'BVP'     # GT signal type
+    numLevels = 2        # depth of the filesystem collecting video and BVP files
+    numSubjects = 8     # number of subjects
+    video_EXT = 'avi'    # extension of the video files
+    frameRate = 30       # vieo frame rate
+    VIDEO_SUBSTRING = ''  # substring contained in the filename
+    SIG_EXT = 'xmp'     # extension of the BVP files
+    SIG_SUBSTRING = '' # substring contained in the filename
+    SIG_SampleRate = 62 # sample rate of the BVP files
+    skinThresh = [40,60]  # thresholds for skin detection
+
+    def readSigfile(self, filename):
+        """ Load BVP signal.
+            Must return a 1-dim (row array) signal
+        """
+        gtTrace = []
+        gtTime = []
+        gtHR = []
+        with open(filename, 'r') as csvfile:
+            xmp = csv.reader(csvfile)
+            for row in xmp:
+                gtTrace.append(float(row[3]))
+                gtTime.append(float(row[0])/1000.)
+                gtHR.append(float(row[1]))
+
+        data = np.array(gtTrace)
+        time = np.array(gtTime)
+        hr = np.array(gtHR)
+        self.SIG_SampleRate = np.round(1/np.mean(np.diff(time)))
+
+        '''import matplotlib.pyplot as plt
+        plt.plot(hr)
+        plt.show()'''
+
+        return BVPsignal(data, self.SIG_SampleRate)

ubfc2.py

@@ -0,0 +1,55 @@
+import csv
+import numpy as np
+from pyVHR.datasets.dataset import Dataset
+from pyVHR.signals.bvp import BVPsignal
+
+class UBFC2(Dataset):
+    """
+    UBFC dataset structure:
+    -----------------
+        datasetDIR/
+        |   |-- SubjDIR1/
+        |       |-- vid.avi
+        |...
+        |   |-- SubjDIRM/
+        |       |-- vid.avi
+    """
+    name = 'UBFC2'
+    signalGT = 'BVP'     # GT signal type
+    numLevels = 2        # depth of the filesystem collecting video and BVP files
+    numSubjects = 26     # number of subjects
+    video_EXT = 'avi'    # extension of the video files
+    frameRate = 30       # vieo frame rate
+    VIDEO_SUBSTRING = ''  # substring contained in the filename
+    SIG_EXT = 'txt'     # extension of the BVP files
+    SIG_SUBSTRING = '' # substring contained in the filename
+    SIG_SampleRate = 30 # sample rate of the BVP files
+    skinThresh = [40,60]  # thresholds for skin detection
+
+    def readSigfile(self, filename):
+        """ Load BVP signal.
+            Must return a 1-dim (row array) signal
+        """
+        gtTrace = []
+        gtTime = []
+        gtHR = []
+        with open(filename, 'r') as f:
+            x = f.readlines()
+        
+        s = x[0].split(' ')
+        s = list(filter(lambda a: a != '', s))
+        gtTrace = np.array(s).astype(np.float64)
+
+        t = x[2].split(' ')
+        t = list(filter(lambda a: a != '', t))
+        gtTime = np.array(t).astype(np.float64)
+        
+        hr = x[1].split(' ')
+        hr = list(filter(lambda a: a != '', hr))
+        gtHR = np.array(hr).astype(np.float64)
+
+        data = np.array(gtTrace)
+        time = np.array(gtTime)
+        self.SIG_SampleRate = np.round(1/np.mean(np.diff(time)))
+
+        return BVPsignal(data, self.SIG_SampleRate)

utils.py

@@ -0,0 +1,275 @@
+"""
+A utils module used in the actual evm module performing such tasks as
+pyramid construction, video io and filter application
+
+functions were originally written by flyingzhao but adapted for this module
+"""
+
+import cv2
+import numpy as np
+import scipy.signal as signal
+import scipy.fftpack as fftpack
+
+def build_gaussian_pyramid(src, levels=3):
+	"""
+	Function: build_gaussian_pyramid
+	--------------------------------
+		Builds a gaussian pyramid
+
+	Args:
+	-----
+		src: the input image
+		levels: the number levels in the gaussian pyramid
+
+	Returns:
+	--------
+		A gaussian pyramid
+	"""
+	s=src.copy()
+	pyramid=[s]
+	for i in range(levels):
+		s=cv2.pyrDown(s)
+		pyramid.append(s)
+	return pyramid
+
+
+def gaussian_video(video, levels=3):
+	"""
+	Function: gaussian_video
+	------------------------
+		generates a gaussian pyramid for each frame in a video
+
+	Args:
+	-----
+		video: the input video array
+		levels: the number of levels in the gaussian pyramid
+
+	Returns:
+	--------
+		the gaussian video
+	"""
+	n = video.shape[0]
+	for i in range(0, n):
+		pyr = build_gaussian_pyramid(video[i], levels=levels)
+		gaussian_frame=pyr[-1]
+		if i==0:
+			vid_data = np.zeros((n, *gaussian_frame.shape))
+		vid_data[i] = gaussian_frame
+	return vid_data
+
+
+def reconstruct_video_g(amp_video, original_video, levels=3):
+	"""
+	Function: reconstruct_video_g
+	-----------------------------
+		reconstructs a video from a gaussian pyramid and the original
+
+	Args:
+	-----
+		amp_video: the amplified gaussian video
+		original_video: the original video
+		levels: the levels in the gaussian video
+
+	Returns:
+	--------
+		the reconstructed video
+	"""
+	final_video = np.zeros(original_video.shape)
+	for i in range(0, amp_video.shape[0]):
+		img = amp_video[i]
+		for x in range(levels):
+			img = cv2.pyrUp(img)
+		img = img + original_video[i]
+		final_video[i] = img
+	return final_video
+
+
+def build_laplacian_pyramid(src,levels=3):
+	"""
+	Function: build_laplacian_pyramid
+	---------------------------------
+		Builds a Laplacian Pyramid
+
+	Args:
+	-----
+		src: the input image
+		levels: the number levels in the laplacian pyramid
+
+	Returns:
+	--------
+		A Laplacian pyramid
+	"""
+	gaussianPyramid = build_gaussian_pyramid(src, levels)
+	pyramid=[]
+	for i in range(levels,0,-1):
+		GE=cv2.pyrUp(gaussianPyramid[i])
+		L=cv2.subtract(gaussianPyramid[i-1],GE)
+		pyramid.append(L)
+	return pyramid
+
+
+def laplacian_video(video, levels=3):
+	"""
+	Function: laplacian_video
+	-------------------------
+		generates a laplaican pyramid for each frame in a video
+
+	Args:
+	-----
+		video: the input video array
+		levels: the number of levels for each laplacian pyramid
+
+	Returns:
+	--------
+		The laplacian video
+	"""
+	tensor_list=[]
+	n = video.shape[0]
+	for i in range(0, n):
+		frame=video[i]
+		pyr = build_laplacian_pyramid(frame,levels=levels)
+		if i==0:
+			for k in range(levels):
+				tensor_list.append(np.zeros((n, *pyr[k].shape)))
+		for n in range(levels):
+			tensor_list[n][i] = pyr[n]
+	return tensor_list
+
+
+def reconstruct_video_l(lap_pyr, levels=3):
+	"""
+	Function: reconstruct_video_l
+	-----------------------------
+		reconstructs a video from a laplacian pyramid and the original
+
+	Args:
+	-----
+		lap_pyr: the amplified laplacian pyramid
+		levels: the levels in the laplacian video
+
+	Returns:
+	--------
+		the reconstructed video
+	"""
+	final = np.zeros(lap_pyr[-1].shape)
+	for i in range(lap_pyr[0].shape[0]):
+		up = lap_pyr[0][i]
+		for n in range(levels-1):
+			up = cv2.pyrUp(up) + lap_pyr[n + 1][i]
+		final[i] = up
+	return final
+
+
+def save_video(video, filename='out.avi'):
+	"""
+	Function: save_video
+	--------------------
+		saves a video to a file
+
+	Args:
+	-----
+		video: the numpy array representing the video
+		filename: the name of the output file
+
+	Returns:
+		None
+	"""
+	fourcc = cv2.VideoWriter_fourcc('M','J','P','G')
+	n, h, w, _ = video.shape
+	writer = cv2.VideoWriter(filename, fourcc, 30, (w, h), 1)
+	for i in range(0, n):
+		writer.write(cv2.convertScaleAbs(video[i]))
+	writer.release()
+
+
+def load_video(video_filename):
+	"""
+	Function: load_video
+	--------------------
+		Loads a video from a file
+
+	Args:
+	-----
+		video_filename: the name of the video file
+
+	Returns:
+	--------
+		a numpy array with shape (num_frames, height, width, channels)
+		the frame rate of the video
+	"""
+	cap = cv2.VideoCapture(video_filename)
+
+	frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+	width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+	height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+	fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+	video = np.zeros((frame_count, height, width, 3), dtype='float')
+	x = 0
+	while cap.isOpened():
+		ret, frame = cap.read()
+		if ret is True:
+			video[x] = frame
+			x += 1
+		else:
+			break
+	return video, fps
+
+
+def temporal_ideal_filter(arr, low, high, fps, axis=0):
+	"""
+	Function: temporal_ideal_filter
+	-------------------------------
+		Applies a temporal ideal filter to a numpy array
+
+	Args:
+	-----
+		arr: a numpy array with shape (N, H, W, C)
+			N: number of frames
+			H: height
+			W: width
+			C: channels
+		low: the low frequency bound
+		high: the high frequency bound
+		fps: the video frame rate
+		axis: the axis of video, should always be 0
+
+	Returns:
+	--------
+		the array with the filter applied
+	"""
+	fft = fftpack.fft(arr, axis=axis)
+	frequencies = fftpack.fftfreq(arr.shape[0], d=1.0 / fps)
+	bound_low = (np.abs(frequencies - low)).argmin()
+	bound_high = (np.abs(frequencies - high)).argmin()
+	fft[:bound_low] = 0
+	fft[bound_high:-bound_high] = 0
+	fft[-bound_low:] = 0
+	iff=fftpack.ifft(fft, axis=axis)
+	return np.abs(iff)
+
+
+def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
+	"""
+	Function: butter_bandpass_filter
+	--------------------------------
+		applies a buttersworth bandpass filter
+
+	Args:
+	-----
+		data: the input data
+		lowcut: the low cut value
+		highcut: the high cut value
+		fs: the frame rate in frames per second
+		order: the order for butter
+
+	Returns:
+	--------
+		the result of the buttersworth bandpass filter
+	"""
+	omega = 0.5 * fs
+	low = lowcut / omega
+	high = highcut / omega
+	b, a = signal.butter(order, [low, high], btype='band')
+	y = signal.lfilter(b, a, data, axis=0)
+	return y

video.py

@@ -0,0 +1,703 @@
+import os
+import re
+import warnings
+
+import dlib
+import matplotlib.pyplot as plt
+import skvideo
+import skvideo.io
+from matplotlib import patches
+
+from .pyramid import *
+from ..utils import printutils
+from ..utils.SkinDetect import SkinDetect
+
+
+class Video:
+    """
+    Basic class for extracting ROIs from video frames
+    """
+
+    facePadding = 0.2      # dlib param for padding
+    filenameCompressed = "croppedFaces.npz"   # filename to store on disk
+    saveCropFaces = True   # enable the storage on disk of the cropped faces
+    loadCropFaces = True   # enable the loading of cropped faces from disk
+
+
+    def __init__(self, filename, verb=0):
+        self.filename = filename
+        self.faces = np.array([])        # empty array of cropped faces (RGB)
+        self.processedFaces = np.array([])
+        self.faceSignal = np.array([])   # empty array of face signals (RGB) after roi/skin extraction
+        
+        self.verb = verb
+        self.cropSize = [150, 150]       # param for cropping
+        self.typeROI = 'rect'            # type of rois between ['rect', 'skin']
+        self.detector = 'mtcnn'
+        self.time_vid_start = 0
+
+        self.doEVM = False
+        self.EVMalpha = 20
+        self.EVMlevels = 3
+        self.EVMlow = .8
+        self.EVMhigh = 4
+
+
+        self.rectCoords = [[0, 0, self.cropSize[0], self.cropSize[1]]]  # default 'rect' roi coordinates
+        self.skinThresh_fix = [40, 80]  # default min values of Sauturation and Value (HSV) for 'skin' roi
+        self.skinThresh_adapt = 0.2
+
+    def getCroppedFaces(self, detector='mtcnn', extractor='skvideo', fps=30):
+        """ Time is in seconds"""
+
+        # -- check if cropped faces already exists on disk
+        path, name = os.path.split(self.filename)
+        filenamez = path + '/' + self.filenameCompressed
+     
+        self.detector = detector
+        self.extractor = extractor
+
+        # -- if compressed exists... load it
+        if self.loadCropFaces and os.path.isfile(filenamez):
+            self.cropped = True
+            data = np.load(filenamez, allow_pickle=True)
+            self.faces = data['a']
+            self.numFrames = int(data['b'])
+            self.frameRate = int(data['c'])
+            self.height = int(data['d'])
+            self.width = int(data['e'])
+            self.duration = float(data['f'])
+            self.codec = data['g']
+            self.detector = data['h']
+            self.extractor = data['i']
+            self.cropSize = self.faces[0].shape
+
+            if self.detector != detector:
+                warnings.warn("\nWARNING!! Requested detector method is different from the saved one\n")
+
+        # -- if compressed does not exist, load orig. video and extract faces
+        else:
+            self.cropped = False
+
+            # if the video signal is stored in video container
+            if os.path.isfile(self.filename):
+                # -- metadata
+                metadata = skvideo.io.ffprobe(self.filename)
+                self.numFrames = int(eval(metadata["video"]["@nb_frames"]))
+                self.height = int(eval(metadata["video"]["@height"]))
+                self.width = int(eval(metadata["video"]["@width"]))
+                self.frameRate = int(np.round(eval(metadata["video"]["@avg_frame_rate"])))
+                self.duration = float(eval(metadata["video"]["@duration"]))
+                self.codec = metadata["video"]["@codec_name"]
+                # -- load video on a ndarray with skvideo or openCV
+                video = None
+                if extractor == 'opencv':
+                    video = self.__opencvRead()
+                else:
+                    video = skvideo.io.vread(self.filename)
+                 
+            # else if the video signal is stored as single frames
+            else:    # elif os.path.isdir(self.filename):
+                # -- load frames on a ndarray
+                self.path = path
+                video = self.__loadFrames()
+                self.numFrames = len(video)
+                self.height = video[0].shape[0]
+                self.width = video[0].shape[1]
+                self.frameRate = fps  ###### <<<<----- TO SET MANUALLY ####
+                self.duration = self.numFrames/self.frameRate
+                self.codec = 'raw'
+
+            # -- extract faces and resize
+            print('\n\n' + detector + '\n\n')
+            self.__extractFace(video, method=detector)
+
+            # -- store cropped faces on disk
+            if self.saveCropFaces:
+                np.savez_compressed(filenamez, a=self.faces,
+                                    b=self.numFrames, c=self.frameRate,
+                                    d=self.height, e=self.width,
+                                    f=self.duration, g=self.codec,
+                                    h=self.detector, i=self.extractor)
+
+        if '1' in str(self.verb):
+            self.printVideoInfo()
+            if not self.cropped: 
+                print('      Extracted faces: not found! Detecting...')
+            else:
+                print('      Extracted faces: found! Loading...')
+
+    def setMask(self, typeROI='rect', 
+                rectCoords=None, rectRegions=None, 
+                skinThresh_fix=None, skinThresh_adapt=None):
+        self.typeROI = typeROI
+        if self.typeROI == 'rect':
+            if rectCoords is not None:
+                # List of rectangular ROIs: [[x0,y0,w0,h0],...,[xk,yk,wk,hk]]
+                self.rectCoords = rectCoords
+            elif rectRegions is not None:
+                # List of rectangular regions: ['forehead', 'lcheek', 'rcheek', 'nose']
+                self.rectCoords = self.__rectRegions2Coord(rectRegions)
+        elif self.typeROI == 'skin_adapt' and skinThresh_adapt is not None:
+            # Skin limits for HSV
+            self.skinThresh_adapt = skinThresh_adapt
+        elif self.typeROI == 'skin_fix' and skinThresh_fix is not None:
+            # Skin limits for HSV
+            self.skinThresh_fix = skinThresh_fix
+        else:
+            raise ValueError('Unrecognized type of ROI provided.')
+
+    def extractSignal(self, frameSubset, count=None):
+        if self.typeROI == 'rect':
+            return self.__extractRectSignal(frameSubset)
+
+        elif self.typeROI == 'skin_adapt' or self.typeROI == 'skin_fix':
+            return self.__extractSkinSignal(frameSubset, count)
+
+    def setEVM(self, enable=True, alpha=20, levels=3, low=.8, high=4):
+        """Eulerian Video Magnification"""
+
+        #rawFaces = self.faces
+        #gaussFaces = gaussian_video(rawFaces, levels=levels)
+        #filtered = temporal_ideal_filter(gaussFaces, low, high, self.frameRate)
+        #amplified = alpha * filtered
+        #self.faces = reconstruct_video_g(amplified, rawFaces, levels=levels)
+        self.doEVM = enable
+
+        if enable is True:
+            self.EVMalpha = alpha
+            self.EVMlevels = levels
+            self.EVMlow = low
+            self.EVMhigh = high
+
+    def applyEVM(self):
+        vid_data = gaussian_video(self.faces, self.EVMlevels)
+        vid_data = temporal_bandpass_filter(vid_data, self.frameRate, 
+                                            freq_min=self.EVMlow, 
+                                            freq_max=self.EVMhigh)
+        vid_data *= self.EVMalpha
+        self.processedFaces = combine_pyramid_and_save(vid_data, 
+                                                       self.faces, 
+                                                       enlarge_multiple=3, 
+                                                       fps=self.frameRate)
+        
+    def getMeanRGB(self):
+
+        n_frames = len(self.faceSignal)
+        n_roi = len(self.faceSignal[0])
+        rgb = np.zeros([3, n_frames])
+
+        for i in range(n_frames):
+            mean_rgb = 0
+
+            for roi in self.faceSignal[i]:
+                idx = roi != 0
+                idx2 = np.logical_and(np.logical_and(idx[:, :, 0], idx[:, :, 1]), idx[:, :, 2])
+                roi = roi[idx2]
+                if len(roi) == 0:
+                    mean_rgb += 0
+                else:
+                    mean_rgb += np.mean(roi, axis=0)
+                
+            rgb[:, i] = mean_rgb/n_roi
+        return rgb
+    
+    def printVideoInfo(self):
+        print('\n   * Video filename: %s' %self.filename)
+        print('         Total frames: %s' %self.numFrames)
+        print('             Duration: %s (sec)' %np.round(self.duration,2))
+        print('           Frame rate: %s (fps)' % self.frameRate)
+        print('                Codec: %s' % self.codec)
+        
+        printOK = 1
+        try:
+            f = self.numFrames
+        except AttributeError:
+            printOK = 0
+            
+        if printOK:
+            print('           Num frames: %s' % self.numFrames)
+            print('               Height: %s' % self.height)
+            print('                Width: %s' % self.height)
+            print('             Detector: %s' % self.detector)
+            print('            Extractor: %s' % self.extractor)
+            
+    def printROIInfo(self):
+        print('      ROI type: ' + self.typeROI)
+        if self.typeROI == 'rect':
+            print('   Rect coords: ' + str(self.rectCoords))
+        elif self.typeROI == 'skin_fix':
+            print('   Skin thresh: ' + str(self.skinThresh_fix))
+        elif self.typeROI == 'skin_adapt':
+            print('   Skin thresh: ' + str(self.skinThresh_adapt))
+
+    def showVideo(self):
+        from ipywidgets import interact
+        import ipywidgets as widgets
+
+        n = self.numFrames
+        def view_image(frame):
+            
+            idx = frame-1
+
+            if self.processedFaces.size == 0:
+                face = self.faces[idx]
+            else:
+                face = self.processedFaces[idx]
+
+            if self.typeROI == 'rect':
+                plt.imshow(face, interpolation='nearest')
+                
+                ax = plt.gca()                
+        
+                for coord in self.rectCoords:
+                    rect = patches.Rectangle((coord[0],coord[1]),
+                            coord[2],coord[3],linewidth=1,edgecolor='y',facecolor='none')
+                    ax.add_patch(rect)
+
+            elif self.typeROI == 'skin_fix':
+                lower = np.array([0, self.skinThresh_fix[0], self.skinThresh_fix[1]], dtype = "uint8")
+                upper = np.array([20, 255, 255], dtype = "uint8")
+                converted = cv2.cvtColor(face, cv2.COLOR_RGB2HSV)
+                skinMask = cv2.inRange(converted, lower, upper)
+                skinFace = cv2.bitwise_and(face, face, mask=skinMask)                
+                plt.imshow(skinFace, interpolation='nearest')
+                
+            elif self.typeROI == 'skin_adapt':     
+                sd = SkinDetect(strength=self.skinThresh_adapt)
+                sd.compute_stats(face)
+                skinFace = sd.get_skin(face, filt_kern_size=7, verbose=False, plot=False)     
+                plt.imshow(skinFace, interpolation='nearest')
+
+        interact(view_image, frame=widgets.IntSlider(min=1, max=n, step=1, value=1))
+
+    def __opencvRead(self):
+        vid = cv2.VideoCapture(self.filename)
+        frames = []
+        retval, frame = vid.read()
+        while retval == True:
+            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            retval, frame = vid.read()
+        vid.release()
+        return np.asarray(frames)
+
+    def __extractRectSignal(self, frameSubset):
+        """ Extract R,G,B values on all ROIs of a frame subset """
+        
+        assert self.processedFaces.size > 0, "Faces are not processed yet! Please call runOffline first"
+
+        self.faceSignal = []
+
+        i = 0
+        for r in frameSubset:
+            face = self.processedFaces[r]
+            H = face.shape[0]
+            W = face.shape[1]
+            
+            # take frame-level rois
+            rois = []
+            for roi in self.rectCoords:
+                x = roi[0]
+                y = roi[1]
+                w = min(x + roi[2], W)
+                h = min(y + roi[3], H)
+                rois.append(face[y:h,x:w,:])
+
+            # take all rois of the frame
+            self.faceSignal.append(rois)
+            i += 1
+
+    def __extractSkinSignal(self, frameSubset, count=None, frameByframe=False):
+        """ Extract R,G,B values from skin-based roi of a frame subset """
+        
+        assert self.processedFaces.size > 0, "Faces are not processed yet! Please call runOffline first"
+
+        self.faceSignal = []
+        
+        cp = self.cropSize
+        skinFace = np.zeros([cp[0], cp[1], 3], dtype='uint8')
+
+        # -- loop on frames
+        for i, r in enumerate(frameSubset):
+            face = self.processedFaces[r]
+
+            if self.typeROI == 'skin_fix':        
+                assert len(self.skinThresh_fix) == 2, "Please provide 2 values for Fixed Skin Detector"           
+                lower = np.array([0, self.skinThresh_fix[0], self.skinThresh_fix[1]], dtype = "uint8")
+                upper = np.array([20, 255, 255], dtype = "uint8")
+                converted = cv2.cvtColor(face, cv2.COLOR_RGB2HSV)
+                skinMask = cv2.inRange(converted, lower, upper)
+                skinFace = cv2.bitwise_and(face, face, mask=skinMask)
+                self.faceSignal.append([skinFace])
+        
+            elif self.typeROI == 'skin_adapt':  
+                if count == 0 and i == 0:
+                    self.sd = SkinDetect(strength=self.skinThresh_adapt)
+                    self.sd.compute_stats(face)
+                
+                if frameByframe and i > 0:
+                    self.sd.compute_stats(face)
+                
+                skinFace = self.sd.get_skin(face, filt_kern_size=0, verbose=False, plot=False)
+
+                self.faceSignal.append([skinFace])
+
+    def __extractFace(self, video, method, t_downsample_rate=2):
+
+        # -- save on GPU
+        # self.facesGPU = cp.asarray(self.faces)  # move the data to the current device.
+
+        if method == 'dlib':
+            # -- dlib detector
+            detector = dlib.get_frontal_face_detector()
+            if os.path.exists("resources/shape_predictor_68_face_landmarks.dat"):
+                file_predict = "resources/shape_predictor_68_face_landmarks.dat"
+            elif os.path.exists("../resources/shape_predictor_68_face_landmarks.dat"):
+                file_predict = "../resources/shape_predictor_68_face_landmarks.dat"
+            predictor = dlib.shape_predictor(file_predict)
+            self.faces = np.zeros([self.numFrames, self.cropSize[0], self.cropSize[1], 3],
+                                  dtype='uint8')
+
+            # -- loop on frames
+            cp = self.cropSize
+            self.faces = np.zeros([self.numFrames, cp[0], cp[1], 3], dtype='uint8')
+            for i in range(self.numFrames):
+                frame = video[i, :, :, :]
+                # -- Detect face using dlib
+                self.numFaces = 0
+                facesRect = detector(frame, 0)
+                if len(facesRect) > 0:
+                    # -- process only the first face
+                    self.numFaces += 1
+                    rect = facesRect[0]
+                    x0 = rect.left()
+                    y0 = rect.top()
+                    w = rect.width()
+                    h = rect.height()
+
+                    # -- extract cropped faces
+                    shape = predictor(frame, rect)
+                    f = dlib.get_face_chip(frame, shape, size=self.cropSize[0], padding=self.facePadding)
+                    self.faces[i, :, :, :] = f.astype('uint8')
+
+                if self.verb: printutils.printProgressBar(i, self.numFrames, prefix='Processing:', suffix='Complete', length=50)
+
+                else:
+                    print("No face detected at frame %s",i)
+
+        elif method == 'mtcnn_kalman':
+            # mtcnn detector
+            from mtcnn import MTCNN
+            detector = MTCNN()
+
+            h0 = None
+            w0 = None
+            crop = np.zeros([2, 2, 2])
+            skipped_frames = 0
+            
+            while crop.shape[:2] != (h0,w0):
+                if skipped_frames > 0:
+                    print("\nWARNING! Strange Face Crop... Skipping frame " + str(skipped_frames) + '...')
+                frame = video[skipped_frames, :, :, :]
+                detection = detector.detect_faces(frame)
+                
+                if len(detection) > 1:
+                    areas = []
+                    for det in detection:
+                        areas.append(det['box'][2] * det['box'][3])
+                    areas = np.array(areas)
+                    ia = np.argsort(areas)
+                    [x0, y0, w0, h0] = detection[ia[-1]]['box']
+                else:
+                    [x0, y0, w0, h0] = detection[0]['box']
+
+                w0 = 2*(int(w0/2))
+                h0 = 2*(int(h0/2))
+                #Cropping face
+                crop = frame[y0:y0+h0, x0:x0+w0, :]
+
+                skipped_frames += 1
+
+            self.cropSize = crop.shape[:2]
+
+            if skipped_frames > 1:
+                self.numFrames = self.numFrames - skipped_frames
+                new_time_vid_start = skipped_frames / self.frameRate
+
+                if new_time_vid_start > self.time_vid_start:
+                    self.time_vid_start = new_time_vid_start
+                    print("\tVideo now starts at " + str(self.time_vid_start) + " seconds\n")
+            
+            self.faces = np.zeros([self.numFrames, self.cropSize[0], self.cropSize[1], 3], dtype='uint8')
+            self.faces[0, :, :, :] = crop
+
+            #set the initial tracking window
+            state = np.array([int(x0+w0/2), int(y0+h0/2), 0, 0], dtype='float64') # initial position
+
+            #Setting up Kalman Filter
+            kalman = cv2.KalmanFilter(4, 2, 0)
+            kalman.transitionMatrix = np.array([[1., 0., .1, 0.],
+                                                [0., 1., 0., .1],
+                                                [0., 0., 1., 0.],
+                                                [0., 0., 0., 1.]])
+            kalman.measurementMatrix = 1. * np.eye(2, 4)
+            kalman.processNoiseCov = 1e-5 * np.eye(4, 4)
+            kalman.measurementNoiseCov = 1e-3 * np.eye(2, 2)
+            kalman.errorCovPost = 1e-1 * np.eye(4, 4)
+            kalman.statePost = state
+            measurement = np.array([int(x0+w0/2), int(y0+h0/2)], dtype='float64')
+
+            for i in range(skipped_frames, self.numFrames):
+                frame = video[i, :, :, :]
+
+                if i%t_downsample_rate == 0:
+                    detection = detector.detect_faces(frame)
+                    if len(detection) != 0:
+                        areas = []
+                        if len(detection) > 1:
+                            for det in detection:
+                                areas.append(det['box'][2] * det['box'][3])
+                            areas = np.array(areas)
+                            ia = np.argsort(areas)
+
+                            [x0, y0, w, h] = detection[ia[-1]]['box']
+                        else:
+                            [x0, y0, w, h] = detection[0]['box']
+                        
+                        not_found = False
+                    else:
+                        not_found = True
+
+                prediction = kalman.predict() #prediction
+
+                if i%t_downsample_rate == 0 and not not_found:
+                    measurement = np.array([x0+w/2, y0+h/2], dtype='float64')
+                    posterior = kalman.correct(measurement)
+                    [cx0, cy0, wn, hn] = posterior.astype(int)
+                else:
+                    [cx0, cy0, wn, hn] = prediction.astype(int)
+
+                # Cropping with new bounding box
+                crop = frame[int(cy0-h0/2):int(cy0+h0/2), int(cx0-w0/2):int(cx0+w0/2), :]
+
+                if crop.shape[:2] != self.faces.shape[1:3]:
+                    print("WARNING! Strange face crop: video frame " + str(i) +" probably does not contain the whole face... Reshaping Crop\n")
+                    crop = cv2.resize(crop, (self.faces.shape[2], self.faces.shape[1]))
+
+                self.faces[i, :, :, :] = crop.astype('uint8')
+
+        elif method == 'mtcnn':
+            # mtcnn detector
+            from mtcnn import MTCNN
+            # from utils.FaceAligner import FaceAligner
+            detector = MTCNN()
+
+            print("\nPerforming face detection...")
+
+            h0 = None
+            w0 = None
+            crop = np.zeros([2, 2, 2])
+            skipped_frames = 0
+            
+            while crop.shape[:2] != (h0, w0):
+                if skipped_frames > 0:
+                    print("\nWARNING! Strange Face Crop... Skipping frame " + str(skipped_frames) + '...')
+                frame = video[skipped_frames, :, :, :]
+                detection = detector.detect_faces(frame)
+
+                if len(detection) == 0:
+                    skipped_frames += 1
+                    continue
+                
+                if len(detection) > 1:
+                    areas = []
+                    for det in detection:
+                        areas.append(det['box'][2] * det['box'][3])
+                    areas = np.array(areas)
+                    ia = np.argsort(areas)
+                    [x0, y0, w0, h0] = detection[ia[-1]]['box']
+                    nose = detection[ia[-1]]['keypoints']['nose']
+                    r_eye = detection[ia[-1]]['keypoints']['right_eye']
+                    l_eye = detection[ia[-1]]['keypoints']['left_eye']
+                else:
+                    [x0, y0, w0, h0] = detection[0]['box']
+                    nose = detection[0]['keypoints']['nose']
+                    r_eye = detection[0]['keypoints']['right_eye']
+                    l_eye = detection[0]['keypoints']['left_eye']
+
+                w0 = 2*(int(w0/2))
+                h0 = 2*(int(h0/2))
+                barycenter = (np.array(nose) + np.array(r_eye) + np.array(l_eye)) / 3.
+                cy0 = barycenter[1]
+                cx0 = barycenter[0]
+                # Cropping face
+                crop = frame[int(cy0-h0/2):int(cy0+h0/2), int(cx0-w0/2):int(cx0+w0/2), :]
+
+                skipped_frames += 1
+
+            # fa = FaceAligner(desiredLeftEye=(0.3, 0.3),desiredFaceWidth=w0, desiredFaceHeight=h0)
+            # crop_align = fa.align(frame, r_eye, l_eye)
+
+            self.cropSize = crop.shape[:2]
+
+            if skipped_frames > 1:
+                self.numFrames = self.numFrames - skipped_frames
+                new_time_vid_start = skipped_frames / self.frameRate
+
+                if new_time_vid_start > self.time_vid_start:
+                    self.time_vid_start = new_time_vid_start
+                    print("\tVideo now starts at " + str(self.time_vid_start) + " seconds\n")
+            
+            self.faces = np.zeros([self.numFrames, self.cropSize[0], self.cropSize[1], 3], dtype='uint8')
+            self.faces[0, :, :, :] = crop
+
+            old_detection = detection
+            for i in range(skipped_frames,self.numFrames):
+                # print('\tFrame ' + str(i) + ' of ' + str(self.numFrames))
+                frame = video[i, :, :, :]
+
+                new_detection = detector.detect_faces(frame)
+                areas = []
+
+                if len(new_detection) == 0:
+                    new_detection = old_detection
+            
+                if len(new_detection) > 1:
+                    for det in new_detection:
+                        areas.append(det['box'][2] * det['box'][3])
+                    areas = np.array(areas)
+                    ia = np.argsort(areas)
+
+                    [x0, y0, w, h] = new_detection[ia[-1]]['box']
+                    nose = new_detection[ia[-1]]['keypoints']['nose']
+                    r_eye = new_detection[ia[-1]]['keypoints']['right_eye']
+                    l_eye = new_detection[ia[-1]]['keypoints']['left_eye']
+                else:
+                    [x0, y0, w, h] = new_detection[0]['box']
+                    nose = new_detection[0]['keypoints']['nose']
+                    r_eye = new_detection[0]['keypoints']['right_eye']
+                    l_eye = new_detection[0]['keypoints']['left_eye']
+                    
+                barycenter = (np.array(nose) + np.array(r_eye) + np.array(l_eye)) / 3.
+                cy0 = barycenter[1]
+                cx0 = barycenter[0]
+                #Cropping with new bounding box
+                crop = frame[int(cy0-h0/2):int(cy0+h0/2), int(cx0-w0/2):int(cx0+w0/2), :]
+
+                if crop.shape[:2] != self.faces.shape[1:3]:
+                    print("WARNING! Strange face crop: video frame " + str(i) +" probably does not contain the whole face... Reshaping Crop\n")
+                    crop = cv2.resize(crop, (self.faces.shape[2], self.faces.shape[1]))
+
+                self.faces[i, :, :, :] = crop.astype('uint8')
+                old_detection = new_detection
+        
+                #if self.verb: 
+                printutils.printProgressBar(i, self.numFrames, prefix = 'Processing:', suffix = 'Complete', length = 50)
+        else:
+
+            raise ValueError('Unrecognized Face detection method. Please use "dlib" or "mtcnn"')
+
+    def __rectRegions2Coord(self, rectRegions):
+      
+        # regions 'forehead'
+        #         'lcheek'
+        #         'rcheek'
+        #         'nose'
+        assert len(self.faces) > 0, "Faces not found, please run getCroppedFaces first!"
+
+        w = self.faces[0].shape[1]
+        h = self.faces[0].shape[0]
+        
+        coords = []
+
+        for roi in rectRegions:
+            if roi == 'forehead':
+                if self.detector == 'dlib':
+                    x_f = int(w * .34)
+                    y_f = int(h * .05)
+                    w_f = int(w * .32)
+                    h_f = int(h * .05)
+
+                elif (self.detector == 'mtcnn') or (self.detector == 'mtcnn_kalman'):
+                    x_f = int(w * .20)
+                    y_f = int(h * .10)
+                    w_f = int(w * .60)
+                    h_f = int(h * .12)
+
+                coords.append([x_f, y_f, w_f, h_f])
+
+            elif roi == 'lcheek':
+                if self.detector == 'dlib':
+                    x_c = int(w * .22)
+                    y_c = int(h * .40)
+                    w_c = int(w * .14)
+                    h_c = int(h * .11)
+
+                elif (self.detector == 'mtcnn') or (self.detector == 'mtcnn_kalman'):
+                    x_c = int(w * .15)
+                    y_c = int(h * .54)
+                    w_c = int(w * .15)
+                    h_c = int(h * .11)
+
+                coords.append([x_c, y_c, w_c, h_c])
+
+            elif roi == 'rcheek':
+                if self.detector == 'dlib':
+                    x_c = int(w * .64)
+                    y_c = int(h * .40)
+                    w_c = int(w * .14)
+                    h_c = int(h * .11)
+
+                elif (self.detector == 'mtcnn') or (self.detector == 'mtcnn_kalman'):
+                    x_c = int(w * .70)
+                    y_c = int(h * .54)
+                    w_c = int(w * .15)
+                    h_c = int(h * .11)
+
+                coords.append([x_c, y_c, w_c, h_c])
+
+            elif roi == 'nose':
+                if self.detector == 'dlib':
+                    x_c = int(w * .40)
+                    y_c = int(h * .35)
+                    w_c = int(w * .20)
+                    h_c = int(h * .05)
+
+                elif (self.detector == 'mtcnn') or (self.detector == 'mtcnn_kalman'):
+                    x_c = int(w * .35)
+                    y_c = int(h * .50)
+                    w_c = int(w * .30)
+                    h_c = int(h * .08)
+
+                coords.append([x_c, y_c, w_c, h_c])
+
+            else:
+                raise ValueError('Unrecognized rect region name.')
+
+        return coords
+
+    def __sort_nicely(self, l): 
+        """ Sort the given list in the way that humans expect. 
+        """ 
+        convert = lambda text: int(text) if text.isdigit() else text 
+        alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] 
+        l.sort( key=alphanum_key )
+        return l
+
+    def __loadFrames(self):
+        
+        # -- delete the compressed if exists
+        cmpFile = os.path.join(self.path, self.filenameCompressed)
+        if os.path.exists(cmpFile):
+            os.remove(cmpFile)
+        
+        # -- get filenames within dir
+        f_names = self.__sort_nicely(os.listdir(self.path))
+        frames = []
+        for n in range(len(f_names)):
+            filename = os.path.join(self.path, f_names[n])
+            frames.append(cv2.imread(filename)[:, :, ::-1])
+        
+        frames = np.array(frames)
+        return frames
+