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