воскресенье, 26 июня 2011 г.

Реализация методов фильтрации высокочастотных шумов


Проблема фильтрации сигналов традиционно привлекала внимание в самых разных областях науки и техники, что обусловлено практической важностью ее решения. В данной статье мы реализуем два основных метода фильтрации шума в сигналах: метод адаптивной  прямой пороговой фильтрации и  метод анизотропной фильтрации.

1. Задание

Дана матрица входного сигнала x(n1, n2):


0          0          20        20        15        15        20        20        0          0          0          0         
0          16        43        46        33        34        47        39        12        0          0          0         
0          24        55        62        47        53        75        62        32        12        4          0         
8          37        74        69        74        88        98        89        64        40        15        0         
6          51        75        91        111      129      141      115       92        65        47        24       
4          34        62        84        88        105      105      83        55        36        30        18       
8          22        34        59        77        77        79        64        43        31        27        12       
0          16        38        49        35        49        93        70        31        12        21        18       
0          0          12        31        40        33        34        41        45        18        0          0         
0          0          0          0          20        27        14        4          6         12        0          0         
0          0          0          0          0          6          4         0          0          0          0         0            



В указанных местах вставляем две помехи:

0          0          20        20        15        15        20        20        0          0          0          0         
0          16        43        46        33        34        47        39        12        0          0          0         
0          24        55        62        47        53        75        62        32        12        4          0         
8          37        120      69        74        88        98        89        64        40        15        0         
6          51        75        91        111      129      141      160       92        65        47        24       
4          34        62        84        88        105      105      83        55        36        30        18       
8          22        34        59        77        77        79        64        43        31        27        12       
0          16        38        49        35        49        93        70        31        12        21        18       
0          0          12        31        40        33        34        41        45        18        0          0         
0          0          0          0          20        27       14        4           6         12        0          0         
0          0          0          0          0          6         4          0          0          0         0          0
               



Задача состоит в том, чтобы избавиться от помех с помощью двух оконных фильтров (3х3 ):

1)    Методом анизотропной фильтрации.
Набор весовых коэффициентов окна:
            1 1 1
            1 2 1
            1 1 1
Нормировочный коэффициент: 1/10 ( 10 = 1+1+1+1+2+1+1+1+1 )

2)    Методом адаптивной  прямой пороговой фильтрации.
m = 1.35

Формула:
 | x(n1, n2) – g(n1, n2) | < mδ(n1, n2)
В результате мы должны получить отфильтрованную(разными методами) матрицу y(n1, n2), а также матрицу невязки r(n1, n2) = | x(n1, n2) - y(n1, n2) |.

2. Листинг программы
Программы написана на языке C++ в среде разработки MS Visual Studio .NET 2010.
Функция, реализующая метод адаптивной  прямой пороговой фильтрации.

int*  getFilteredMatrAdapt(int xx[])
{
      int i, j, k1, k2;
      int *x_f, *x;
      x_f = new int[rows*cols];
      x = new int[rows*cols];

      for(i=0; i
            x_f[i] = 0;

      for(i=0; i
            for(j=0; j
                  x[i*cols+j] = xx[i*cols+j];

      x[3*cols+2]=120;
      x[4*cols+7]=160;

      float g=0.0, sigma=0.0;

      for(k1=0; k1<(rows-3); k1++)
      {
            for(k2=0; k2<(cols-3); k2++)
            {
                  for(i=k1; i
                        for(j=k2; j
                              g += x[i*cols +j]/9;

                  for(i=k1; i
                        for(j=k2; j
                             sigma += (x[i*cols +j]-g)*(x[i*cols +j]-g)/9;
                  sigma = sqrt(sigma);

                  for(i=k1; i
                        for(j=k2; j
                             if( x_f[i*cols +j]==0 )
                                   if( abs( x[i*cols +j]-g ) >= m*sigma )
                                   {
                                         x[i*cols +j] = (int)g;
                                         x_f[i*cols +j] = 1;
                                   }
            }
      }
      return x;
}

Функция, реализующая метод анизотропной фильтрации.

int * getFilteredMatrAniz(int xx[])
{
      int i, j, k1, k2;
      int *x;
      float central;
      int l[] = { 1,1,1,
                        1,2,1,
                        1,1,1 };
      x = new int[rows*cols];

      for(i=0; i
            for(j=0; j
                  x[i*cols+j] = xx[i*cols+j];

      x[3*cols+2]=120;
      x[4*cols+7]=160;

      for(k1=0; k1<(rows-3); k1++)
      {
            for(k2=0; k2<(cols-3); k2++)
            {
                  central = 0.0;

                  for(i=k1; i
                        for(j=k2; j
                        {
                        central += x[i*cols +j] * l[ (i-k1)*3 + j-k2 ] /10;
                        }
                  x[ (k1+1)*3 + k2+1 ] = (int)central;
            }
      }
      return x;
}

Инизиализация матрицы и параметров, вызовы методов фильтрования матрицы.

#define rows 11
#define cols 12
#define m 1.35

int _tmain()
{
      int *y, *r1, *r2, *y2;
      y = new int[rows*cols];
      r1 = new int[rows*cols];
      r2 = new int[rows*cols];
      y2 = new int[rows*cols];
      int x[rows*cols] = {0,0,20,20,15,15,20,20,0,0,0,0,  
                          0,16,43,46,33,34,47,39,12,0,0,0,
                          0,24,55,62,47,53,75,62,32,12,4,0,
                          8,37,74,69,74,88,98,89,64,40,15,0,
                          6,51,75,91,111,129,141,115,92,65,47,24,
                          4,34,62,84,88,105,105,83,55,36,30,18,
                          8,22,34,59,77,77,79,64,43,31,27,12,
                          0,16,38,49,35,49,93,70,31,12,21,18,
                          0,0,12,31,40,33,34,41,45,18,0,0,
                          0,0,0,0,20,27,14,4,6,12,0,0,
                          0,0,0,0,0,6,4,0,0,0,0,0
                         };
      FILE* f1=fopen("saraj3_adapt_x_filtered.txt","w");
      FILE* f2=fopen("saraj3_adapt_raznost.txt","w");
      //FILE* f3=fopen("saraj3_aniz_x_filtered.txt","w");
      //FILE* f4=fopen("saraj3_aniz_raznost.txt","w");
     
      y = getFilteredMatrAdapt(x);
      //y2 = getFilteredMatrAniz(x);

      for(int i=0; i
            for(int j=0; j
            {
                  r1[i*cols+j] = abs(y[i*cols+j] - x[i*cols+j]);
                  //r2[i*cols+j] = abs(y2[i*cols+j] - x[i*cols+j]);
            }

      printMatr(f1, y, rows, cols);
      printMatr(f2, r1, rows, cols);
      //printMatr(f3, y2, rows, cols);
      //printMatr(f4, r2, rows, cols);
      return 0;
}


3. Результаты работы

1) Метод анизотропной фильтрации.
Отфильтрованная матрица  y(n1, n2):

0          0          20        20        16        30        36        30        49        57        38        67       
74        41        67        83        29        54        72        20        38        53        12        26       
38        5          13        23        29        34        36        35        26        14        4          0         
8          37        120       69        74        88        98        89        64        40        15        0         
6          51        75        91        111       129       141       160       92        65        47        24       
4          34        62        84        88        105       105       83        55        36        30        18       
8          22        34        59        77        77        79        64        43        31        27        12       
0          16        38        49        35        49        93        70        31        12        21        18       
0          0          12        31        40        33        34        41        45        18        0          0         
0          0          0          0          20        27        14        4          6          12        0          0         
0          0          0          0          0          6          4          0          0          0          0          0         



Матрица невязки r(n1, n2):

0          0          0          0          1          15        16        10        49        57        38        67       
74        25        24        37        4          20        25        19        26        53        12        26       
38        19        42        39        18        19        39        27        6          2          0          0         
0          0          46        0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          45        0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         



2) Метод  адаптивной  прямой пороговой фильтрации.
Отфильтрованная матрица  y(n1, n2):

0          35        20        20        15        15        20        20        0          0          0          0         
0          16        15        46        33        34        47        39        12        0          0          0         
0          24        15        62        47        53        75        62        32        12        4          0         
8          37        120       69        74        88        98        89        64        40        15        0         
6          51        75        91        111       129       141       160       92        65        47        24       
4          34        62        84        88        105       105       83        55        36        30        18       
8          22        34        59        77        77        79        64        43        31        27        12       
0          16        38        49        35        49        93        70        31        12        21        18       
0          0          12        31        40        33        34        41        45        18        0          0         
0          0          0          0          20        27        14        4          6          12        0          0         
0          0          0          0          0          6          4          0          0          0          0          0         



Матрица невязки r(n1, n2):

0          35        0          0          0          0          0          0          0          0          0          0         
0          0          28        0          0          0          0          0          0          0          0          0         
0          0          40        0          0          0          0          0          0          0          0          0         
0          0          46        0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          45        0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         
0          0          0          0          0          0          0          0          0          0          0          0         



Выводы
В данной статье были рассмотрены и реализованы два основных метода фильтрации шума в сигналах: метод адаптивной  прямой пороговой фильтрации и  метод анизотропной фильтрации.
А также были представлены экспериментальные результаты проверки работоспособности методов на примерах реальных сигналов.

Комментариев нет:

Отправить комментарий