WIP: rPPG as features for PAD

Hey all,

So I'm working on this rPPG features for PAD. Right now, I implemented three different algorithms to retrieve the pulse signal, and they are all based on what I previously did in bob.rppg.base (and hence, bob.pad.face should then depend on it eventually).

At the moment, all pulse extraction algorithm are implemented as bob.pad.face.Extractor, but the more I think about it, I think that they should be implemented as bob.pad.face.Preprocessor for mainly two reasons:

1. Solves the problem with rotated videos directly (instead of having an "empty" preprocessor copying data)
2. Gives the ability to then extract features from the pulse (i.e. frequency spectrum, for instance)

@amohammadi @onikisins @dgeissbuhler @andre.anjos @ageorge @pkorshunov any comments, remarks, suggestions on the best way to integrate that in this package are welcomed

Thanks !

bob/pad/face/extractor/FFTFeatures.py

+#!/usr/bin/env python
+# encoding: utf-8
+
+import numpy
+
+from bob.bio.base.extractor import Extractor
+
+import logging
+logger = logging.getLogger("bob.pad.face")
+
+
+class FFTFeatures(Extractor, object):
+  """
+  Compute the Frequency Spectrum of the given signal.
+
+  The computation is made using numpy's rfft routine 
+
+  **Parameters:**
+
+  framerate: int
+    The sampling frequency of the signal (i.e the framerate ...) 
+
+  nfft: int
+    Number of points to compute the FFT
+
+  debug: boolean
+    Plot stuff
+  """
+  def __init__(self, framerate=25, nfft=256, debug=False, **kwargs):
+
+    super(FFTFeatures, self).__init__(**kwargs)
+    
+    self.framerate = framerate
+    self.nfft = nfft
+    self.debug = debug
+
+
+  def __call__(self, signal):
+    """
+    Compute the frequency spectrum for the given signal.
+
+    **Parameters:**
+
+    signal: numpy.array 
+      The signal
+
+    **Returns:**
+
+      freq: numpy.array 
+       the frequency spectrum 
+    """
+    # sanity check
+    if signal.ndim == 1:
+      if numpy.isnan(numpy.sum(signal)):
+        return
+    if signal.ndim == 2 and (signal.shape[1] == 3):
+      if numpy.isnan(numpy.sum(signal[:, 1])):
+        return
+
+    output_dim = int((self.nfft / 2) + 1)
+    
+    # get the frequencies
+    f = numpy.fft.fftfreq(self.nfft) * self.framerate
+   
+    # we have a single pulse signal
+    if signal.ndim == 1:
+      fft = abs(numpy.fft.rfft(signal, n=self.nfft))
+
+    # we have 3 pulse signal (Li's preprocessing)
+    # in this case, return the signal corresponding to the green channel
+    if signal.ndim == 2 and (signal.shape[1] == 3):
+      ffts = numpy.zeros((3, output_dim))
+      for i in range(3):
+        ffts[i] = abs(numpy.fft.rfft(signal[:, i], n=self.nfft))
+      fft = ffts[1]
+      
+    if self.debug: 
+      from matplotlib import pyplot
+      pyplot.plot(f, fft, 'k')
+      pyplot.title('Power spectrum of the signal')
+      pyplot.show()
+
+    return fft