自适应波束形成(五)——Frost波束形成2

  • Post author:
  • Post category:其他


上篇是对matlab模拟产生的阵列接收语音进行增强,这篇主要是利用Frost波束形成器对真实信号进行增强。



1  测试环境

采集环境为6*3.7*3.4m

3

的测试室,用恒通DAR2000多路音频采集卡(如图1左),通过D型音频接线口与由烽火PK-080VH微型数字针孔拾音器(如图1右)组成的麦克风阵列相连,采集8路真实语音信号进行语音增强测试。

图1 DAR2000多路音频采集卡和 PK-080VH微型数字针孔拾音器



2 C++源码

这里仅仅是测试算法,所以没有加入读取音频及写音频部分的代码,通过将音频数据存放于txt中简单存取。

#define BOUNDS_CHECK

#include 
  
  
   
   
#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      
#include 
      
      
        #include 
       
         #include 
        
          #include 
         
           #include 
          
            #include 
           
             #include 
            
              #include "engine.h" using namespace std; using namespace splab; typedef double Type; const int M=8,N=38454,fs=8000,J=20; //麦克风数 const double theta=-PI*30.0/180.0,mu=0.00002; //指向角-30 const Type c=Type(340.0); const Type d=Type(0.064); const Type Ts=1.0/fs; //计算时延 Type delay(int m) { Type T=(M-1)*d/c; //cout< 
             
               < 
              
                =0.5) { return Dd+1; } else { return Dd-1; }*/ return D; } int delay1(int m) { Type T=M*d/c; //cout< 
               
                 < 
                
                  =0.5) { return Dd+1; } else { return Dd-1; } } //分数时延滤波器 Vector 
                 
                   h(int m) { Vector 
                  
                    H(10); for(int n=0; n<10; n++) { H[n]=1; for(int k=0; k<=10; k++) { Type nk=n-k; if(k!=n) H[n]*=((delay(m)-k)/nk); //cout< 
                   
                     < 
                    
                      Cons() { Matrix 
                     
                       C(M*J,J); for(int i=0; i 
                      
                        c(M*J); for(int j=0; j 
                       
                         fcon() { Vector 
                        
                          f(J); f[0]=1; return f; } //计算C(C^TC)^-1 Matrix 
                         
                           Cc() { Matrix 
                          
                            C=Cons(); Matrix 
                           
                             CTC(J,J); for(int i=0; i 
                            
                              CTCinv=inv(CTC); Matrix 
                             
                               CC(M*J,J); for(int i=0; i 
                              
                                Fcon() { Matrix 
                               
                                 CCI=Cc(); Vector 
                                
                                  f=fcon(); Vector 
                                 
                                   F(M*J); for(int i=0; i 
                                  
                                    Pcon() { Matrix 
                                   
                                     CCI=Cc(); Matrix 
                                    
                                      C=Cons(); Matrix 
                                     
                                       CCIC(M*J,M*J); for(int i=0; i 
                                      
                                        I(M*J,M*J); for( int i=0; i 
                                       
                                         P=I-CCIC; return P; } Matrix 
                                        
                                          DELAY(Matrix 
                                         
                                           &x) { int Len=x.cols(); Matrix 
                                          
                                            yd(M,Len); for(int n=0; n 
                                           
                                             xd(M,10); for(int row=0; row 
                                            
                                              y(M); for(int row=0; row 
                                             
                                               H=h(row); y[row]=dotProd(H,xd.getRow(row)); } yd.setColumn(y,n); } return yd; } //时域lcmv Vector 
                                              
                                                lcmvtime(Matrix 
                                               
                                                 &x,const int M) { int Len=x.cols(); //数据长度 //Vector 
                                                
                                                  hw=hamming(WL,A); //汉明窗 Vector 
                                                 
                                                   w=Fcon(); //cout< 
                                                  
                                                    < 
                                                   
                                                     y(Len); Matrix 
                                                    
                                                      P=Pcon(); Vector 
                                                     
                                                       F=Fcon(); for(int n=0; n 
                                                      
                                                        xx(M,J); for(int row=0; row 
                                                       
                                                         x_in(M*J); for(int i=0; i 
                                                        
                                                          w1=w-mu*y[n]*x_in; //cout< 
                                                         
                                                           < 
                                                          
                                                            Pw(M*J); for(int i=0; i 
                                                           
                                                             ReadData(int a) { const char*filename[8]={"0.txt","1.txt","2.txt","3.txt","4.txt","5.txt","6.txt","7.txt"}; Vector 
                                                            
                                                              In(N); ifstream fin(filename[a]); for(int i=0;i 
                                                             
                                                               >In[i]; } fin.close(); fin.clear(); return In; } int main() { //各麦克风输出信号 /*Vector 
                                                              
                                                                In_0=ReadData(0); Vector 
                                                               
                                                                 In_1=ReadData(1); Vector 
                                                                
                                                                  In_2=ReadData(2); Vector 
                                                                 
                                                                   In_3=ReadData(3); Vector 
                                                                  
                                                                    In_4=ReadData(4); Vector 
                                                                   
                                                                     In_5=ReadData(5); Vector 
                                                                    
                                                                      In_6=ReadData(6); Vector 
                                                                     
                                                                       In_7=ReadData(7);*/ //cout< 
                                                                      
                                                                        < 
                                                                       
                                                                                  < 
                                                                                  
                                                                                 
                                                                                
                                                                               
                                                                              
                                                                             
                                                                            
                                                                           
                                                                          
                                                                         
                                                                        
                                                                       
                                                                      
                                                                     
                                                                    
                                                                   
                                                                  
                                                                 
                                                                
                                                               
                                                              
                                                             
                                                            
                                                           
                                                          
                                                         
                                                        
                                                       
                                                      
                                                     
                                                    
                                                   
                                                  
                                                 
                                                
                                               
                                              
                                             
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
      
     
     
    
    
   
   
  
  

其中时延用的是整数时延,最后是用vs调用matlab画图。



3 增强效果

在60

o

方向有一女声说“我在60

o

”,-30

o

方向有一男声“我在-30

o

”,首先两人分别单独说,然后两人同时说,采样频率为8kHz,8个拾音器线性排列,间距6.4cm。先对-30

o

方向的男声进行增强,结果如图2所示。

图2 增强-30

o

男声信号

上图的上半部分是第一个麦克风采集的混合语音,下半部分是对-30

o

男声进行增强后的语音。由于前面两段波形是两人单独说话时的波形,对这两段波形分析可发现,60

o

语音信号波形明显衰减,-30

o

语音信号波形基本不变。将-30

o

语音作为期望信号,60

o

语音作为噪声,增强前信噪比约为3.6364dB,增强后信噪比约为8.0330dB,信噪比增益4.3966dB。

然后对60

o

方向的女声语音进行增强,结果如图3所示。

图3  增强60

o

女声信号

上图的上半部分是第一个麦克风采集的混合语音,下半部分是对60

o

女声进行增强后的语音。对前面两段两人单独说话时的波形分析可发现,60

o

语音信号波形基本不变,-30

o

语音信号波形明显衰减。将60

o

语音作为期望信号,-30

o

语音作为噪声,增强前信噪比约为-3.6364dB,增强后信噪比约为8.2396dB,信噪比增益11.8760dB。

由以上实验可知,Frost波束形成器能明显增强期望方向上的语音信号,衰减干扰方向的语音信号,但由于不同人声频率的差异,增强效果有所差别。



版权声明:本文为YJJat1989原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。