File size: 4,803 Bytes
39b4c8c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 |
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_
|