def filter(self, f):
'''
根据输入的null值包含的角度的个数，计算不同的阵列系数
'''
while len(self.null_directions_list) < (self._equations_num - 1):
self.null_directions_list.append(self.null_directions_list[-1])
s_list = [np.eye(self.M)]
s_factor = 1
for i in np.arange(1, len(self.null_directions_list)):
if self.null_directions_list[i] != self.null_directions_list[i-1]:
s_list.append(np.eye(self.M))
else:
s_list.append((np.diag(np.arange(self.M))) ** s_factor)
s_factor = s_factor + 1
D = np.zeros((self._equations_num, self.M), dtype=np.complex)
D[0,:] = hermitian(self.steer_vector(f, self.phi))
for i in np.arange(1, self._equations_num):
D[i,:] = s_list[i-1].dot(self.steer_vector(f, self.null_directions_list[i-1]).conj()).T
il = np.zeros(self._equations_num)
il[0] = 1
il = il.reshape(self._equations_num, 1)
filter = hermitian(D).dot(pinv(D.dot(hermitian(D)))).dot(il)
return filter
def filter(self, f):
H = self._h_matrix(f)
dt = hermitian(H).dot(self.steer_vector(f, self.phi))
g_mwng = pinv(hermitian(H).dot(H)).dot(dt) / hermitian(dt).dot(
pinv(hermitian(H).dot(H))).dot(dt)
filter = H.dot(g_mwng)
return filter
def snr_direct_method(self, f):
'''
Estimate the single-channel Wiener gain directly
'''
hw = hermitian(self.steer_vector(f, self.phi)).dot(self.observed_signal_gamma(f) - \
self.isotropic_noise_coherence(f)).dot(self.steer_vector(f, self.phi)) / \
(self.M ** 2 - hermitian(self.steer_vector(f, self.phi)).dot(self.isotropic_noise_coherence(f)).dot(self.steer_vector(f, self.phi)))
return dB(hw)[0][0]
def _h_matrix(self, f):
filter_nr = NonRobust(self.d_mic, self.order + 1, self.order,
self.alpha).filter(f)
A = np.concatenate((np.conj([filter_nr[0]]), np.zeros(
(self.M - 2, 1))),
axis=0)
B = np.concatenate((hermitian(filter_nr), np.zeros((1, self.M - 2))),
axis=1)
return hermitian(toeplitz(A, B))
def filter(self, f):
H = self._h_matrix(f)
dt = hermitian(H).dot(self.steer_vector(f, self.phi))
R = hermitian(H).dot(self._gamma(f, epsilon=0)).dot(H)
g_Ls = pinv(R).dot(hermitian(H)).dot(self._gamma_dpc(f)).dot(
self.alpha)
g_Cls = g_Ls + ((1 - hermitian(dt).dot(g_Ls)) \
/ (hermitian(dt).dot(pinv(R)).dot(dt))) * (pinv(R)).dot(dt)
filter = H.dot(g_Cls)
return filter
def filter(self, f):
filter = self.steer_vector(f, theta=self.phi)
sig_cov = np.dot(filter.reshape(self.M, 1),
filter.conj().reshape(1, self.M))
noise_cov = self.diffuse_noise_coherence(f)
X, D = jeig(sig_cov, noise_cov, True)
T_matrix = X[:, 0:self.subspace]
P_matrix = T_matrix.dot(pinv(hermitian(T_matrix).dot(T_matrix))).dot(
hermitian(T_matrix))
filter = P_matrix.dot(filter) / hermitian(filter).dot(P_matrix).dot(
filter)
return filter
def filter(self, f):
filter = self.steer_vector(f, theta=self.phi)
noise_cov_pinv = pinv(self.diffuse_noise_coherence(f, self.alpha))
filter = np.dot(
noise_cov_pinv,
filter) / hermitian(filter).dot(noise_cov_pinv).dot(filter)
return filter
def filter(self, f):
V = np.c_[self.steer_vector(f, self.phi), self.steer_vector(f, self.null_directions),
np.diag(np.arange(self.M)).dot(self.steer_vector(f, self.null_directions)),
(np.diag(np.arange(self.M)) ** 2).dot(self.steer_vector(f, self.null_directions))]
eye = np.array([1,0,0,0]).reshape(4,1)
filter = np.dot(pinv(hermitian(V)), eye)
return filter
def filter(self, f):
Gamma_0_90 = self._gamma(f, [0, np.pi/2])
Gamma_90_180 = self._gamma(f, [np.pi/2, np.pi])
X, _ = jeig(Gamma_0_90, Gamma_90_180)
T1 = X[:,0]
filter = T1 / hermitian(self.steer_vector(f, self.phi)).dot(T1)
return filter
def filter(self, f):
filts_ls = super(RegularizedConstrainedLeastSquares, self).filter(f)
d = self.steer_vector(f, self.phi)
d_h = hermitian(d)
C = pinv(self._gamma(f, self.epsilon))
filter = filts_ls - (
(1 - d_h.dot(filts_ls)) / d_h.dot(C).dot(d)) * C.dot(d)
return filter
def broadband_performance_dict(self):
'''
Compute the preformace value for an adaptive array.
Return
------
A dict contains 'array gain',
'noise reduction factor',
'signal reduction facor',
'signal distortion index' values
'''
#数字信号宽带计算频率，计算自适应Beamformer的一些性质（宽带的）
freq = np.linspace(-0.5, 0.5, num=1000,
endpoint=True) * 1 / self.sound_field.Ts
freq = freq[1:-1]
# 初始化一些矩阵
filter_vec = np.zeros((self.M, len(freq)), dtype=np.complex) #滤波器系数
steer_vec = np.zeros((self.M, len(freq)), dtype=np.complex) #导向矢量
observed_cov_vec = np.zeros((self.M, self.M, len(freq)),
dtype=np.complex) #观测矩阵相关系数
noise_cov_vec = np.zeros((self.M, self.M, len(freq)),
dtype=np.complex) #噪声的相关系数矩阵
desired_var_vec = np.zeros(len(freq), dtype=np.complex) #期望信号方差
noise_var_vec = self.sound_field.noise_signal_var * np.ones(
len(freq)) #第一个阵元噪声的方差
#赋值
for i, f in enumerate(freq):
filter_vec[:, i] = self.filter(f).T
steer_vec[:, i] = self.steer_vector(f, self.phi).T
desired_var_vec[i] = self.sound_field.desired_signal_var(f)
observed_cov_vec[:, :, i] = self.sound_field.observed_signal_cov(f)
noise_cov_vec[:, :, i] = self.sound_field.noise_signal_cov(f)
# 输出的信号和噪声的能量
output_signal_energy = desired_var_vec.dot(
np.abs(np.sum(filter_vec.conj() * steer_vec,
axis=0))**2) #宽带输出信号能量
output_noise_energy = 0
#equations-8
for i, f in enumerate(freq):
output_noise_energy += hermitian(filter_vec[:, i]).dot(
noise_cov_vec[:, :, i]).dot(filter_vec[:, i]) #宽带输出噪声能量
# 属性字典
performance_dict = {'array gain' : dB(output_signal_energy / output_noise_energy, power=True) \
- self.sound_field._iSNR.get('dB_value'),
'noise reduction factor' : dB(np.sum(noise_var_vec) / output_noise_energy, power=True),
'signal reduction factor': dB(np.sum(desired_var_vec) / output_signal_energy, power=True),
'signal distortion index': dB((desired_var_vec.dot(np.abs(np.sum(filter_vec.conj() * \
steer_vec, axis=0) - 1) ** 2)) / np.sum(desired_var_vec), power=True)
}
return performance_dict
def filter(self, f):
# constructe C Matrix
theta = [self.phi]
theta.extend(self.interferences) #
C_matrix = self.steer_vector(f, theta=theta)
i_c = np.zeros(len(theta))
i_c[0] = 1
filter = C_matrix.dot(pinv(hermitian(C_matrix).dot(C_matrix))).dot(i_c)
return filter
def noise_signal_cov(self, f):
'''
计算噪声的协方差矩阵，数值仿真中需要计算，但实际使用的时候得设法估计噪声的统计特性
'''
noise_coherence = self.noise_coherence(f)
desired_var = self.desired_signal_var(f)
sigma2 = desired_var / self.sound_field._iSNR.get(
'value') / noise_coherence[0, 0]
if self.ksnap:
C = cholesky(noise_coherence)
np.random.seed(1253)
V0 = np.dot(hermitian(C),
np.random.randn(int(self.M), int(self.ksnap)))
V = sigma2**0.5 * V0
noise_cov = np.dot(V, hermitian(V)) / self.ksnap
else:
noise_cov = sigma2 * noise_coherence
return noise_cov
def white_noise_gain(self, f):
'''
For fixed beamforming, the WNG equals to 1 / w.conj().T * w
And in delay and sum the w equals to steervector / self.N
Parameters
----------
f: float
frequency
'''
wng = 1 / np.dot(hermitian(self.filter(f)), self.filter(f))
return dB(wng, True)
def filter(self, f):
observed_cov = self.sound_field.observed_signal_cov(f)
theta = [
self.phi, *self.sound_field._noise_signal_dict.get(
'interferences').get('directions')
]
C = self.steer_vector(f, theta=theta)
i_c = np.zeros(len(theta))
i_c[0] = 1
filter = pinv(observed_cov).dot(
C.dot(pinv(hermitian(C).dot(pinv(observed_cov)).dot(C))).dot(i_c))
return filter
def filter(self, f):
"""
Compute omega of the MaxDF filter
----------------------
Parameters
f: frequency
"""
filter = self.steer_vector(f, theta=self.phi)
noise_cov_pinv = pinv(self.diffuse_noise_coherence(f))
filter = np.dot(
noise_cov_pinv,
filter) / hermitian(filter).dot(noise_cov_pinv).dot(filter)
return filter
def beam_pattern(self, f):
'''
Compute and Plot beampattern response for microphone array
Parameters
----------
f: float
frequency
'''
omega = self.filter(f)
steer_vector = self.steer_vector(f)
response = np.squeeze(dB(np.abs(hermitian(steer_vector).dot(omega))))
return response
def directivity(self, f):
'''
Directivity factor of microphone array
note: python sinc function is sinc(pi*x) / pi*x
Parameters
----------
f: float
frequency
'''
noise_cov = self.diffuse_noise_coherence(f)
di = 1 / hermitian(self.filter(f)).dot(noise_cov).dot(self.filter(f))
return dB(di, True)
def filter(self, f):
# constructe C Matrix
theta = [self.phi]
theta.extend(self.interferences) #
C_matrix = self.steer_vector(f, theta=theta)
i_c = np.zeros(len(theta))
i_c[0] = 1
noise_cov = self.diffuse_noise_coherence(f, self.alpha)
filter = pinv(noise_cov).dot(C_matrix).dot(
pinv(hermitian(C_matrix).dot(
pinv(noise_cov)).dot(C_matrix))).dot(i_c)
return filter
def filter(self, f):
H = self._h_matrix(f)
dt = hermitian(H).dot(self.steer_vector(f, self.phi))
R = hermitian(H).dot(self._gamma(f, epsilon=0)).dot(H)
R_mu = self.mu * R + (1 - self.mu) * hermitian(H).dot(H)
G_u = self.mu * pinv(R_mu).dot(hermitian(H)).dot(
self._gamma_dpc(f)).dot(self.alpha)
G_t = G_u + (
(1 - hermitian(dt).dot(G_u)) /
(hermitian(dt).dot(inv(R_mu).dot(dt)))) * pinv(R_mu).dot(dt)
filter = H.dot(G_t)
return filter
def filter(self, f):
alpha = self.diffuse_noise_coherence(f)
filter = self.steer_vector(f, self.phi) #phi must be 0 to fulfill cos(theta)=1
filter = np.dot(pinv(alpha), filter) / hermitian(filter).dot(pinv(alpha)).dot(filter)
return filter
def filter(self, f):
d = self.steer_vector(f, self.phi)
observed_cov = self.sound_field.observed_signal_cov(f)
filter = pinv(observed_cov).dot(d) / hermitian(d).dot(
pinv(observed_cov)).dot(d)
return filter
def filter(self, f):
B = self.b_matrix_left(f)
C = pinv(self._gamma(f, self.epsilon))
A = hermitian(B)
filter = C.dot(A).dot(pinv(B.dot(C).dot(A))).dot(self.alpha)
return filter
def filter(self, f):
V = np.c_[self.steer_vector(f, self.phi), self.steer_vector(f, self.null_directions[0]),
self.steer_vector(f, self.null_directions[1])]
eye = np.array([1,0,0]).reshape(3,1)
filter = np.dot(pinv(hermitian(V)), eye)
return filter
def filter(self, f):
B = self.b_matrix_left(f)
filter = hermitian(B).dot(inv(B.dot(hermitian(B)))).dot(self.alpha)
return filter
