Podział sygnału na okna

Odpowiedz Nowy wątek
2007-12-18 17:23
Gość2007
0

Wymyśliłem taki kod, który ma dzielić sygnał na okna i robić "coś" z każdym oknem (DFT, FFT, itp):

class Okna
{
    private:
        double **ModulFT;
    public:
        LiczFT(int, short*, int, int , unsigned long );
            LiczDFT(double*, int , int)
};
void Okna::LiczFT(int WyborOkna, short *Probki, int PrzesuniecieOkna, int SzerokoscOkna, unsigned long Rozmiar)
{
    //*Probki - wskaznik na tablice probek
    //Rozmiar - rozmiar tablicy probek
    int KoniecOkna;
    double *Tmp = new double[SzerokoscOkna];
    double *Okno = new double[SzerokoscOkna];
    ModulFT = new double*[(Rozmiar - SzerokoscOkna)/PrzesuniecieOkna];
    for(int i = 0,  k = 0; k < (Rozmiar - SzerokoscOkna)/PrzesuniecieOkna; i+=PrzesuniecieOkna,k++)
    {
          //dla każdego okna
      KoniecOkna = SzerokoscOkna + i;
              for(int c =0; c < SzerokoscOkna;c++)
              {
                   switch(WyborOkna)
                   {    case 0:
                        Tmp[c] = Probki[c] * OknoHamminga(c, Rozmiar);
                        break;
                        case 1:
                        Tmp[c] = Probki[c] * OknoProstokatne(c, Rozmiar);
                        break;
                        case 2:
                        Tmp[c] = Probki[c] * OknoHanna(c, Rozmiar);
                        break;
                        case 3:
                        Tmp[c] = Probki[c] * OknoNuttalla(c, Rozmiar);
                        break;
                  }
              }
            for(int j = i,  z = 0; j < KoniecOkna && z < SzerokoscOkna; j++, z++)
            {
                //dla każdej probki w tym oknie
                               Okno[z] = Probki[j] * Tmp[z];
            }
           ModulFT[k] = new double[SzerokoscOkna];
          //tu wywołuje to co ma liczyć dla danego okna
          LiczDFT(Okno, SzerokoscOkna, k);
        }
delete[] Tmp;
delete[] Okno;
}
void Okna::LiczDFT(double *Probki, int SzerokoscOkna, int k)
{
double sumaDFTre, sumaDFTim;

                for(int l=0 ; l <= SzerokoscOkna - 1; l++)
                {
                   sumaDFTre = 0;
                   sumaDFTim = 0;
                   double Temp = 2* M_PI * l );
                    for(int n = 0; n <= SzerokoscOkna - 1; n++)
                    {
                         sumaDFTre += Probki[n] * (cos(Temp* n/(double)SzerokoscOkna));
                         sumaDFTim += Probki[n] * (-sin(Temp* n/(double)SzerokoscOkna));
                    }
                   ModulFT[k][l] = sqrt(sumaDFTre * sumaDFTre + sumaDFTim * sumaDFTim) / (double)SzerokoscOkna;
                }
}

Moje pytanie jest następujące: Jak zoptymalizować kod aby program był szybszy??(jeśli wywołuję jakąś funkcję dla każdego okna to jest to dosyć wolne rozwiązanie - pętla w pętli w pętli itd.)

Pozostało 580 znaków

2007-12-19 16:22
0

A nie możesz do tej pętli dodać?

for(int n = 0; n <= SzerokoscOkna - 1; n++)
{
   sumaDFTre += Probki[n] * (cos(Temp* n/(double)SzerokoscOkna)) * okno_ptr(...);
   sumaDFTim += Probki[n] * (-sin(Temp* n/(double)SzerokoscOkna)) * okno_ptr(...);
}

okno_ptr to wskaźnik na wybrany typ okna. A! i pozbądź się dzielenia w Temp* n/(double)SzerokoscOkna.

Pozostało 580 znaków

2007-12-20 09:59
Gość2007
0

No faktycznie, odejdzie mi dzięki temu jedna pętla i tablica :)
Dziękuje za pomoc, pozdrawiam!!

Pozostało 580 znaków

2007-12-20 11:52
0

Mała modyfikacja:

double ww = 1.0/double(SzerokoscOkna);
double 2piww = 2* M_PI * ww;

for(int l=0 ; l < SzerokoscOkna ; ++l)
{
    sumaDFTre = 0;
    sumaDFTim = 0;

    double Temp = 2piww * l;

    for(int n = 0; n < SzerokoscOkna ; ++n)
    {
        double a = n * Temp;
        double s = Probki[n] * okno_ptr(...);
        sumaDFTre += s * (cos(a));
        sumaDFTim += s * (-sin(a));
    }

    ModulFT[k][l] = sqrt(sumaDFTre * sumaDFTre + sumaDFTim * sumaDFTim) * ww;
}

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0